]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Give PlotCanvas the full compliment of constructor parameters again.
[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_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3790 return wxPyTestDisplayAvailable();
3791 }
3792
3793 void wxApp_CleanUp() {
3794 __wxPyCleanup();
3795 }
3796
3797
3798 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3799
3800
3801
3802
3803
3804 SWIGINTERNINLINE PyObject *
3805 SWIG_FromCharPtr(const char *cptr)
3806 {
3807 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3808 }
3809
3810
3811 #if 0 // #ifdef __WXMAC__
3812
3813 // A dummy class that raises an exception if used...
3814 class wxEventLoop
3815 {
3816 public:
3817 wxEventLoop() { wxPyRaiseNotImplemented(); }
3818 int Run() { return 0; }
3819 void Exit(int rc = 0) {}
3820 bool Pending() const { return false; }
3821 bool Dispatch() { return false; }
3822 bool IsRunning() const { return false; }
3823 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3824 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3825 };
3826
3827 #else
3828
3829 #include <wx/evtloop.h>
3830
3831 #endif
3832
3833
3834
3835 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3836 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3837 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3838 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3839 wxWindowList& list = self->GetChildren();
3840 return wxPy_ConvertList(&list);
3841 }
3842 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863
3864 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3865 return wxWindow::FindWindowById(id, parent);
3866 }
3867
3868 wxWindow* wxFindWindowByName( const wxString& name,
3869 const wxWindow *parent = NULL ) {
3870 return wxWindow::FindWindowByName(name, parent);
3871 }
3872
3873 wxWindow* wxFindWindowByLabel( const wxString& label,
3874 const wxWindow *parent = NULL ) {
3875 return wxWindow::FindWindowByLabel(label, parent);
3876 }
3877
3878
3879 #ifdef __WXMSW__
3880 #include <wx/msw/private.h> // to get wxGetWindowId
3881 #endif
3882
3883
3884 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3885 #ifdef __WXMSW__
3886 WXHWND hWnd = (WXHWND)_hWnd;
3887 long id = wxGetWindowId(hWnd);
3888 wxWindow* win = new wxWindow;
3889 if (parent)
3890 parent->AddChild(win);
3891 win->SetEventHandler(win);
3892 win->SetHWND(hWnd);
3893 win->SetId(id);
3894 win->SubclassWin(hWnd);
3895 win->AdoptAttributesFromHWND();
3896 win->SetupColours();
3897 return win;
3898 #else
3899 wxPyRaiseNotImplemented();
3900 return NULL;
3901 #endif
3902 }
3903
3904
3905 PyObject* GetTopLevelWindows() {
3906 return wxPy_ConvertList(&wxTopLevelWindows);
3907 }
3908
3909
3910 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3911 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3913
3914 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3915
3916
3917 SWIGINTERNINLINE int
3918 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3919 {
3920 unsigned long v;
3921 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3922 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3923 return res;
3924 }
3925
3926 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3927 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3928 wxMenuItemList& list = self->GetMenuItems();
3929 return wxPy_ConvertList(&list);
3930 }
3931 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3932 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3933 static const wxString wxPyControlNameStr(wxControlNameStr);
3934 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3935 if (clientData) {
3936 wxPyClientData* data = new wxPyClientData(clientData);
3937 return self->Append(item, data);
3938 } else
3939 return self->Append(item);
3940 }
3941 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3942 if (clientData) {
3943 wxPyClientData* data = new wxPyClientData(clientData);
3944 return self->Insert(item, pos, data);
3945 } else
3946 return self->Insert(item, pos);
3947 }
3948 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3949 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3950 if (data) {
3951 Py_INCREF(data->m_obj);
3952 return data->m_obj;
3953 } else {
3954 Py_INCREF(Py_None);
3955 return Py_None;
3956 }
3957 }
3958 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 self->SetClientObject(n, data);
3961 }
3962
3963
3964 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3965 wxPyUserData* data = NULL;
3966 if ( userData ) {
3967 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3968 data = new wxPyUserData(userData);
3969 wxPyEndBlockThreads(blocked);
3970 }
3971 return new wxSizerItem(window, proportion, flag, border, data);
3972 }
3973 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3974 wxPyUserData* data = NULL;
3975 if ( userData ) {
3976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3977 data = new wxPyUserData(userData);
3978 wxPyEndBlockThreads(blocked);
3979 }
3980 return new wxSizerItem(width, height, proportion, flag, border, data);
3981 }
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(sizer, proportion, flag, border, data);
3990 }
3991
3992 SWIGINTERNINLINE PyObject *
3993 SWIG_From_float (float value)
3994 {
3995 return SWIG_From_double (value);
3996 }
3997
3998 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3999 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4000 if (data) {
4001 Py_INCREF(data->m_obj);
4002 return data->m_obj;
4003 } else {
4004 Py_INCREF(Py_None);
4005 return Py_None;
4006 }
4007 }
4008 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 self->SetUserData(data);
4016 }
4017
4018 // Figure out the type of the sizer item
4019
4020 struct wxPySizerItemInfo {
4021 wxPySizerItemInfo()
4022 : window(NULL), sizer(NULL), gotSize(false),
4023 size(wxDefaultSize), gotPos(false), pos(-1)
4024 {}
4025
4026 wxWindow* window;
4027 wxSizer* sizer;
4028 bool gotSize;
4029 wxSize size;
4030 bool gotPos;
4031 int pos;
4032 };
4033
4034 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4035
4036 wxPySizerItemInfo info;
4037 wxSize size;
4038 wxSize* sizePtr = &size;
4039
4040 // Find out what the type of the item is
4041 // try wxWindow
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4043 PyErr_Clear();
4044 info.window = NULL;
4045
4046 // try wxSizer
4047 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4048 PyErr_Clear();
4049 info.sizer = NULL;
4050
4051 // try wxSize or (w,h)
4052 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4053 info.size = *sizePtr;
4054 info.gotSize = true;
4055 }
4056
4057 // or a single int
4058 if (checkIdx && PyInt_Check(item)) {
4059 info.pos = PyInt_AsLong(item);
4060 info.gotPos = true;
4061 }
4062 }
4063 }
4064
4065 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4066 // no expected type, figure out what kind of error message to generate
4067 if ( !checkSize && !checkIdx )
4068 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4069 else if ( checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4071 else if ( !checkSize && checkIdx)
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4073 else
4074 // can this one happen?
4075 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4076 }
4077
4078 return info;
4079 }
4080
4081 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4082 if (!self->GetClientObject())
4083 self->SetClientObject(new wxPyOORClientData(_self));
4084 }
4085 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4086
4087 wxPyUserData* data = NULL;
4088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4089 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4090 if ( userData && (info.window || info.sizer || info.gotSize) )
4091 data = new wxPyUserData(userData);
4092 if ( info.sizer )
4093 PyObject_SetAttrString(item,"thisown",Py_False);
4094 wxPyEndBlockThreads(blocked);
4095
4096 // Now call the real Add method if a valid item type was found
4097 if ( info.window )
4098 return self->Add(info.window, proportion, flag, border, data);
4099 else if ( info.sizer )
4100 return self->Add(info.sizer, proportion, flag, border, data);
4101 else if (info.gotSize)
4102 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4103 proportion, flag, border, data);
4104 else
4105 return NULL;
4106 }
4107 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4108
4109 wxPyUserData* data = NULL;
4110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4111 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4112 if ( userData && (info.window || info.sizer || info.gotSize) )
4113 data = new wxPyUserData(userData);
4114 if ( info.sizer )
4115 PyObject_SetAttrString(item,"thisown",Py_False);
4116 wxPyEndBlockThreads(blocked);
4117
4118 // Now call the real Insert method if a valid item type was found
4119 if ( info.window )
4120 return self->Insert(before, info.window, proportion, flag, border, data);
4121 else if ( info.sizer )
4122 return self->Insert(before, info.sizer, proportion, flag, border, data);
4123 else if (info.gotSize)
4124 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4125 proportion, flag, border, data);
4126 else
4127 return NULL;
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Prepend method if a valid item type was found
4141 if ( info.window )
4142 return self->Prepend(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Prepend(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4153 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4154 wxPyEndBlockThreads(blocked);
4155 if ( info.window )
4156 return self->Remove(info.window);
4157 else if ( info.sizer )
4158 return self->Remove(info.sizer);
4159 else if ( info.gotPos )
4160 return self->Remove(info.pos);
4161 else
4162 return false;
4163 }
4164 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4166 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4167 wxPyEndBlockThreads(blocked);
4168 if ( info.window )
4169 return self->Detach(info.window);
4170 else if ( info.sizer )
4171 return self->Detach(info.sizer);
4172 else if ( info.gotPos )
4173 return self->Detach(info.pos);
4174 else
4175 return false;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4180 wxPyEndBlockThreads(blocked);
4181 if ( info.window )
4182 return self->GetItem(info.window);
4183 else if ( info.sizer )
4184 return self->GetItem(info.sizer);
4185 else if ( info.gotPos )
4186 return self->GetItem(info.pos);
4187 else
4188 return NULL;
4189 }
4190 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 self->SetItemMinSize(info.window, size);
4196 else if ( info.sizer )
4197 self->SetItemMinSize(info.sizer, size);
4198 else if ( info.gotPos )
4199 self->SetItemMinSize(info.pos, size);
4200 }
4201 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4202 wxSizerItemList& list = self->GetChildren();
4203 return wxPy_ConvertList(&list);
4204 }
4205 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 return self->Show(info.window, show, recursive);
4211 else if ( info.sizer )
4212 return self->Show(info.sizer, show, recursive);
4213 else if ( info.gotPos )
4214 return self->Show(info.pos, show);
4215 else
4216 return false;
4217 }
4218 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4220 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4221 wxPyEndBlockThreads(blocked);
4222 if ( info.window )
4223 return self->IsShown(info.window);
4224 else if ( info.sizer )
4225 return self->IsShown(info.sizer);
4226 else if ( info.gotPos )
4227 return self->IsShown(info.pos);
4228 else
4229 return false;
4230 }
4231
4232 // See pyclasses.h
4233 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4234 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4235 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4236
4237
4238
4239
4240 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBPosition(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4247 }
4248
4249 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4250 {
4251 if (source == Py_None) {
4252 **obj = wxGBSpan(-1,-1);
4253 return true;
4254 }
4255 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4256 }
4257
4258
4259 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return false;
4262 if ( ! wxGBPosition_helper(other, &obj) ) {
4263 PyErr_Clear();
4264 return false;
4265 }
4266 return self->operator==(*obj);
4267 }
4268 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4269 wxGBPosition temp, *obj = &temp;
4270 if ( other == Py_None ) return true;
4271 if ( ! wxGBPosition_helper(other, &obj)) {
4272 PyErr_Clear();
4273 return true;
4274 }
4275 return self->operator!=(*obj);
4276 }
4277 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4278 self->SetRow(row);
4279 self->SetCol(col);
4280 }
4281 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4283 PyObject* tup = PyTuple_New(2);
4284 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4285 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4286 wxPyEndBlockThreads(blocked);
4287 return tup;
4288 }
4289 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return false;
4292 if ( ! wxGBSpan_helper(other, &obj) ) {
4293 PyErr_Clear();
4294 return false;
4295 }
4296 return self->operator==(*obj);
4297 }
4298 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4299 wxGBSpan temp, *obj = &temp;
4300 if ( other == Py_None ) return true;
4301 if ( ! wxGBSpan_helper(other, &obj)) {
4302 PyErr_Clear();
4303 return true;
4304 }
4305 return self->operator!=(*obj);
4306 }
4307 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4308 self->SetRowspan(rowspan);
4309 self->SetColspan(colspan);
4310 }
4311 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 PyObject* tup = PyTuple_New(2);
4314 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4315 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4316 wxPyEndBlockThreads(blocked);
4317 return tup;
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(window, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4347 int row, col;
4348 self->GetEndPos(row, col);
4349 return wxGBPosition(row, col);
4350 }
4351 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4352
4353 wxPyUserData* data = NULL;
4354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4355 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4356 if ( userData && (info.window || info.sizer || info.gotSize) )
4357 data = new wxPyUserData(userData);
4358 if ( info.sizer )
4359 PyObject_SetAttrString(item,"thisown",Py_False);
4360 wxPyEndBlockThreads(blocked);
4361
4362 // Now call the real Add method if a valid item type was found
4363 if ( info.window )
4364 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4365 else if ( info.sizer )
4366 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4367 else if (info.gotSize)
4368 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4369 pos, span, flag, border, data);
4370 return NULL;
4371 }
4372
4373
4374 #ifdef __cplusplus
4375 extern "C" {
4376 #endif
4377 SWIGINTERN int EmptyString_set(PyObject *) {
4378 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4379 return 1;
4380 }
4381
4382
4383 SWIGINTERN PyObject *EmptyString_get(void) {
4384 PyObject *pyobj = 0;
4385
4386 {
4387 #if wxUSE_UNICODE
4388 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4389 #else
4390 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #endif
4392 }
4393 return pyobj;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398 PyObject *resultobj = 0;
4399 wxObject *arg1 = (wxObject *) 0 ;
4400 wxString result;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxObject_GetClassName(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 #if wxUSE_UNICODE
4420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4421 #else
4422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4423 #endif
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432 PyObject *resultobj = 0;
4433 wxObject *arg1 = (wxObject *) 0 ;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 PyObject *swig_obj[1] ;
4437
4438 if (!args) SWIG_fail;
4439 swig_obj[0] = args;
4440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4441 if (!SWIG_IsOK(res1)) {
4442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4443 }
4444 arg1 = reinterpret_cast< wxObject * >(argp1);
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 wxObject_Destroy(arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 resultobj = SWIG_Py_Void();
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *obj;
4460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4461 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4462 return SWIG_Py_Void();
4463 }
4464
4465 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 PyObject *resultobj = 0;
4467 wxSize *arg1 = (wxSize *) 0 ;
4468 int arg2 ;
4469 void *argp1 = 0 ;
4470 int res1 = 0 ;
4471 int val2 ;
4472 int ecode2 = 0 ;
4473 PyObject *swig_obj[2] ;
4474
4475 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4477 if (!SWIG_IsOK(res1)) {
4478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4479 }
4480 arg1 = reinterpret_cast< wxSize * >(argp1);
4481 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4482 if (!SWIG_IsOK(ecode2)) {
4483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4484 }
4485 arg2 = static_cast< int >(val2);
4486 if (arg1) (arg1)->x = arg2;
4487
4488 resultobj = SWIG_Py_Void();
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4496 PyObject *resultobj = 0;
4497 wxSize *arg1 = (wxSize *) 0 ;
4498 int result;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502
4503 if (!args) SWIG_fail;
4504 swig_obj[0] = args;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 result = (int) ((arg1)->x);
4511 resultobj = SWIG_From_int(static_cast< int >(result));
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4519 PyObject *resultobj = 0;
4520 wxSize *arg1 = (wxSize *) 0 ;
4521 int arg2 ;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 int val2 ;
4525 int ecode2 = 0 ;
4526 PyObject *swig_obj[2] ;
4527
4528 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4532 }
4533 arg1 = reinterpret_cast< wxSize * >(argp1);
4534 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4537 }
4538 arg2 = static_cast< int >(val2);
4539 if (arg1) (arg1)->y = arg2;
4540
4541 resultobj = SWIG_Py_Void();
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *resultobj = 0;
4550 wxSize *arg1 = (wxSize *) 0 ;
4551 int result;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4561 }
4562 arg1 = reinterpret_cast< wxSize * >(argp1);
4563 result = (int) ((arg1)->y);
4564 resultobj = SWIG_From_int(static_cast< int >(result));
4565 return resultobj;
4566 fail:
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4572 PyObject *resultobj = 0;
4573 int arg1 = (int) 0 ;
4574 int arg2 = (int) 0 ;
4575 wxSize *result = 0 ;
4576 int val1 ;
4577 int ecode1 = 0 ;
4578 int val2 ;
4579 int ecode2 = 0 ;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4582 char * kwnames[] = {
4583 (char *) "w",(char *) "h", NULL
4584 };
4585
4586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4587 if (obj0) {
4588 ecode1 = SWIG_AsVal_int(obj0, &val1);
4589 if (!SWIG_IsOK(ecode1)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4591 }
4592 arg1 = static_cast< int >(val1);
4593 }
4594 if (obj1) {
4595 ecode2 = SWIG_AsVal_int(obj1, &val2);
4596 if (!SWIG_IsOK(ecode2)) {
4597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4598 }
4599 arg2 = static_cast< int >(val2);
4600 }
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 result = (wxSize *)new wxSize(arg1,arg2);
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4608 return resultobj;
4609 fail:
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 PyObject *resultobj = 0;
4616 wxSize *arg1 = (wxSize *) 0 ;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 PyObject *swig_obj[1] ;
4620
4621 if (!args) SWIG_fail;
4622 swig_obj[0] = args;
4623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 delete arg1;
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 resultobj = SWIG_Py_Void();
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___eq__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 PyObject *arg2 = (PyObject *) 0 ;
4679 bool result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 char * kwnames[] = {
4685 (char *) "self",(char *) "other", NULL
4686 };
4687
4688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4690 if (!SWIG_IsOK(res1)) {
4691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4692 }
4693 arg1 = reinterpret_cast< wxSize * >(argp1);
4694 arg2 = obj1;
4695 {
4696 result = (bool)wxSize___ne__(arg1,arg2);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4701 }
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 wxSize *arg1 = (wxSize *) 0 ;
4711 wxSize *arg2 = 0 ;
4712 wxSize result;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 wxSize temp2 ;
4716 PyObject * obj0 = 0 ;
4717 PyObject * obj1 = 0 ;
4718 char * kwnames[] = {
4719 (char *) "self",(char *) "sz", NULL
4720 };
4721
4722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4724 if (!SWIG_IsOK(res1)) {
4725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4726 }
4727 arg1 = reinterpret_cast< wxSize * >(argp1);
4728 {
4729 arg2 = &temp2;
4730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (arg1)->operator +((wxSize const &)*arg2);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 wxSize *arg1 = (wxSize *) 0 ;
4748 wxSize *arg2 = 0 ;
4749 wxSize result;
4750 void *argp1 = 0 ;
4751 int res1 = 0 ;
4752 wxSize temp2 ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "self",(char *) "sz", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4763 }
4764 arg1 = reinterpret_cast< wxSize * >(argp1);
4765 {
4766 arg2 = &temp2;
4767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4768 }
4769 {
4770 PyThreadState* __tstate = wxPyBeginAllowThreads();
4771 result = (arg1)->operator -((wxSize const &)*arg2);
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = 0;
4784 wxSize *arg1 = (wxSize *) 0 ;
4785 wxSize *arg2 = 0 ;
4786 void *argp1 = 0 ;
4787 int res1 = 0 ;
4788 wxSize temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char * kwnames[] = {
4792 (char *) "self",(char *) "sz", NULL
4793 };
4794
4795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4797 if (!SWIG_IsOK(res1)) {
4798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4799 }
4800 arg1 = reinterpret_cast< wxSize * >(argp1);
4801 {
4802 arg2 = &temp2;
4803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4804 }
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 (arg1)->IncTo((wxSize const &)*arg2);
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_Py_Void();
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj = 0;
4820 wxSize *arg1 = (wxSize *) 0 ;
4821 wxSize *arg2 = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char * kwnames[] = {
4828 (char *) "self",(char *) "sz", NULL
4829 };
4830
4831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4833 if (!SWIG_IsOK(res1)) {
4834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4835 }
4836 arg1 = reinterpret_cast< wxSize * >(argp1);
4837 {
4838 arg2 = &temp2;
4839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 (arg1)->DecTo((wxSize const &)*arg2);
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = 0;
4856 wxSize *arg1 = (wxSize *) 0 ;
4857 float arg2 ;
4858 float arg3 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 float val2 ;
4862 int ecode2 = 0 ;
4863 float val3 ;
4864 int ecode3 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4874 if (!SWIG_IsOK(res1)) {
4875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4876 }
4877 arg1 = reinterpret_cast< wxSize * >(argp1);
4878 ecode2 = SWIG_AsVal_float(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4881 }
4882 arg2 = static_cast< float >(val2);
4883 ecode3 = SWIG_AsVal_float(obj2, &val3);
4884 if (!SWIG_IsOK(ecode3)) {
4885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4886 }
4887 arg3 = static_cast< float >(val3);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 (arg1)->Scale(arg2,arg3);
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 int arg2 ;
4905 int arg3 ;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 int val2 ;
4909 int ecode2 = 0 ;
4910 int val3 ;
4911 int ecode3 = 0 ;
4912 PyObject * obj0 = 0 ;
4913 PyObject * obj1 = 0 ;
4914 PyObject * obj2 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "w",(char *) "h", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4921 if (!SWIG_IsOK(res1)) {
4922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 ecode2 = SWIG_AsVal_int(obj1, &val2);
4926 if (!SWIG_IsOK(ecode2)) {
4927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4928 }
4929 arg2 = static_cast< int >(val2);
4930 ecode3 = SWIG_AsVal_int(obj2, &val3);
4931 if (!SWIG_IsOK(ecode3)) {
4932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4933 }
4934 arg3 = static_cast< int >(val3);
4935 {
4936 PyThreadState* __tstate = wxPyBeginAllowThreads();
4937 (arg1)->Set(arg2,arg3);
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 resultobj = SWIG_Py_Void();
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj = 0;
4950 wxSize *arg1 = (wxSize *) 0 ;
4951 int arg2 ;
4952 void *argp1 = 0 ;
4953 int res1 = 0 ;
4954 int val2 ;
4955 int ecode2 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 char * kwnames[] = {
4959 (char *) "self",(char *) "w", NULL
4960 };
4961
4962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4966 }
4967 arg1 = reinterpret_cast< wxSize * >(argp1);
4968 ecode2 = SWIG_AsVal_int(obj1, &val2);
4969 if (!SWIG_IsOK(ecode2)) {
4970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4971 }
4972 arg2 = static_cast< int >(val2);
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 (arg1)->SetWidth(arg2);
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 int arg2 ;
4990 void *argp1 = 0 ;
4991 int res1 = 0 ;
4992 int val2 ;
4993 int ecode2 = 0 ;
4994 PyObject * obj0 = 0 ;
4995 PyObject * obj1 = 0 ;
4996 char * kwnames[] = {
4997 (char *) "self",(char *) "h", NULL
4998 };
4999
5000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5002 if (!SWIG_IsOK(res1)) {
5003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5004 }
5005 arg1 = reinterpret_cast< wxSize * >(argp1);
5006 ecode2 = SWIG_AsVal_int(obj1, &val2);
5007 if (!SWIG_IsOK(ecode2)) {
5008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5009 }
5010 arg2 = static_cast< int >(val2);
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 (arg1)->SetHeight(arg2);
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 wxSize *arg1 = (wxSize *) 0 ;
5027 int result;
5028 void *argp1 = 0 ;
5029 int res1 = 0 ;
5030 PyObject *swig_obj[1] ;
5031
5032 if (!args) SWIG_fail;
5033 swig_obj[0] = args;
5034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5035 if (!SWIG_IsOK(res1)) {
5036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5037 }
5038 arg1 = reinterpret_cast< wxSize * >(argp1);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (int)((wxSize const *)arg1)->GetWidth();
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 resultobj = SWIG_From_int(static_cast< int >(result));
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 PyObject *resultobj = 0;
5054 wxSize *arg1 = (wxSize *) 0 ;
5055 int result;
5056 void *argp1 = 0 ;
5057 int res1 = 0 ;
5058 PyObject *swig_obj[1] ;
5059
5060 if (!args) SWIG_fail;
5061 swig_obj[0] = args;
5062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)((wxSize const *)arg1)->GetHeight();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 bool result;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 if (!args) SWIG_fail;
5089 swig_obj[0] = args;
5090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5091 if (!SWIG_IsOK(res1)) {
5092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5093 }
5094 arg1 = reinterpret_cast< wxSize * >(argp1);
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 wxSize *arg2 = 0 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 wxSize temp2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char * kwnames[] = {
5120 (char *) "self",(char *) "size", NULL
5121 };
5122
5123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5125 if (!SWIG_IsOK(res1)) {
5126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5127 }
5128 arg1 = reinterpret_cast< wxSize * >(argp1);
5129 {
5130 arg2 = &temp2;
5131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5132 }
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 (arg1)->SetDefaults((wxSize const &)*arg2);
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 PyObject *result = 0 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 if (!args) SWIG_fail;
5155 swig_obj[0] = args;
5156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5157 if (!SWIG_IsOK(res1)) {
5158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5159 }
5160 arg1 = reinterpret_cast< wxSize * >(argp1);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (PyObject *)wxSize_Get(arg1);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = result;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *obj;
5176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5177 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5178 return SWIG_Py_Void();
5179 }
5180
5181 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 return SWIG_Python_InitShadowInstance(args);
5183 }
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 double arg2 ;
5189 void *argp1 = 0 ;
5190 int res1 = 0 ;
5191 double val2 ;
5192 int ecode2 = 0 ;
5193 PyObject *swig_obj[2] ;
5194
5195 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5199 }
5200 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5201 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5202 if (!SWIG_IsOK(ecode2)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5204 }
5205 arg2 = static_cast< double >(val2);
5206 if (arg1) (arg1)->x = arg2;
5207
5208 resultobj = SWIG_Py_Void();
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5216 PyObject *resultobj = 0;
5217 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5218 double result;
5219 void *argp1 = 0 ;
5220 int res1 = 0 ;
5221 PyObject *swig_obj[1] ;
5222
5223 if (!args) SWIG_fail;
5224 swig_obj[0] = args;
5225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5226 if (!SWIG_IsOK(res1)) {
5227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5228 }
5229 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5230 result = (double) ((arg1)->x);
5231 resultobj = SWIG_From_double(static_cast< double >(result));
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5239 PyObject *resultobj = 0;
5240 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5241 double arg2 ;
5242 void *argp1 = 0 ;
5243 int res1 = 0 ;
5244 double val2 ;
5245 int ecode2 = 0 ;
5246 PyObject *swig_obj[2] ;
5247
5248 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5250 if (!SWIG_IsOK(res1)) {
5251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5252 }
5253 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5254 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5255 if (!SWIG_IsOK(ecode2)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5257 }
5258 arg2 = static_cast< double >(val2);
5259 if (arg1) (arg1)->y = arg2;
5260
5261 resultobj = SWIG_Py_Void();
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5269 PyObject *resultobj = 0;
5270 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5271 double result;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 PyObject *swig_obj[1] ;
5275
5276 if (!args) SWIG_fail;
5277 swig_obj[0] = args;
5278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 result = (double) ((arg1)->y);
5284 resultobj = SWIG_From_double(static_cast< double >(result));
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 double arg1 = (double) 0.0 ;
5294 double arg2 = (double) 0.0 ;
5295 wxRealPoint *result = 0 ;
5296 double val1 ;
5297 int ecode1 = 0 ;
5298 double val2 ;
5299 int ecode2 = 0 ;
5300 PyObject * obj0 = 0 ;
5301 PyObject * obj1 = 0 ;
5302 char * kwnames[] = {
5303 (char *) "x",(char *) "y", NULL
5304 };
5305
5306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5307 if (obj0) {
5308 ecode1 = SWIG_AsVal_double(obj0, &val1);
5309 if (!SWIG_IsOK(ecode1)) {
5310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5311 }
5312 arg1 = static_cast< double >(val1);
5313 }
5314 if (obj1) {
5315 ecode2 = SWIG_AsVal_double(obj1, &val2);
5316 if (!SWIG_IsOK(ecode2)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5318 }
5319 arg2 = static_cast< double >(val2);
5320 }
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject *swig_obj[1] ;
5340
5341 if (!args) SWIG_fail;
5342 swig_obj[0] = args;
5343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5344 if (!SWIG_IsOK(res1)) {
5345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5346 }
5347 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 delete arg1;
5351
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 resultobj = SWIG_Py_Void();
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj = 0;
5364 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5365 PyObject *arg2 = (PyObject *) 0 ;
5366 bool result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char * kwnames[] = {
5372 (char *) "self",(char *) "other", NULL
5373 };
5374
5375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",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___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5379 }
5380 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5381 arg2 = obj1;
5382 {
5383 result = (bool)wxRealPoint___eq__(arg1,arg2);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5388 }
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj = 0;
5397 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5398 PyObject *arg2 = (PyObject *) 0 ;
5399 bool result;
5400 void *argp1 = 0 ;
5401 int res1 = 0 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "other", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 arg2 = obj1;
5415 {
5416 result = (bool)wxRealPoint___ne__(arg1,arg2);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5431 wxRealPoint *arg2 = 0 ;
5432 wxRealPoint result;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 wxRealPoint temp2 ;
5436 PyObject * obj0 = 0 ;
5437 PyObject * obj1 = 0 ;
5438 char * kwnames[] = {
5439 (char *) "self",(char *) "pt", NULL
5440 };
5441
5442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5444 if (!SWIG_IsOK(res1)) {
5445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5446 }
5447 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5455 wxPyEndAllowThreads(__tstate);
5456 if (PyErr_Occurred()) SWIG_fail;
5457 }
5458 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5459 return resultobj;
5460 fail:
5461 return NULL;
5462 }
5463
5464
5465 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5466 PyObject *resultobj = 0;
5467 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5468 wxRealPoint *arg2 = 0 ;
5469 wxRealPoint result;
5470 void *argp1 = 0 ;
5471 int res1 = 0 ;
5472 wxRealPoint temp2 ;
5473 PyObject * obj0 = 0 ;
5474 PyObject * obj1 = 0 ;
5475 char * kwnames[] = {
5476 (char *) "self",(char *) "pt", NULL
5477 };
5478
5479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5481 if (!SWIG_IsOK(res1)) {
5482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5483 }
5484 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5485 {
5486 arg2 = &temp2;
5487 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5488 }
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj = 0;
5504 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5505 double arg2 ;
5506 double arg3 ;
5507 void *argp1 = 0 ;
5508 int res1 = 0 ;
5509 double val2 ;
5510 int ecode2 = 0 ;
5511 double val3 ;
5512 int ecode3 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 PyObject * obj2 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "x",(char *) "y", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 ecode2 = SWIG_AsVal_double(obj1, &val2);
5527 if (!SWIG_IsOK(ecode2)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5529 }
5530 arg2 = static_cast< double >(val2);
5531 ecode3 = SWIG_AsVal_double(obj2, &val3);
5532 if (!SWIG_IsOK(ecode3)) {
5533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5534 }
5535 arg3 = static_cast< double >(val3);
5536 {
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 wxRealPoint_Set(arg1,arg2,arg3);
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 resultobj = SWIG_Py_Void();
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5550 PyObject *resultobj = 0;
5551 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5552 PyObject *result = 0 ;
5553 void *argp1 = 0 ;
5554 int res1 = 0 ;
5555 PyObject *swig_obj[1] ;
5556
5557 if (!args) SWIG_fail;
5558 swig_obj[0] = args;
5559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5560 if (!SWIG_IsOK(res1)) {
5561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5562 }
5563 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (PyObject *)wxRealPoint_Get(arg1);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = result;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 PyObject *obj;
5579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5580 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5581 return SWIG_Py_Void();
5582 }
5583
5584 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 return SWIG_Python_InitShadowInstance(args);
5586 }
5587
5588 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590 wxPoint *arg1 = (wxPoint *) 0 ;
5591 int arg2 ;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 int val2 ;
5595 int ecode2 = 0 ;
5596 PyObject *swig_obj[2] ;
5597
5598 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5600 if (!SWIG_IsOK(res1)) {
5601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5602 }
5603 arg1 = reinterpret_cast< wxPoint * >(argp1);
5604 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5605 if (!SWIG_IsOK(ecode2)) {
5606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5607 }
5608 arg2 = static_cast< int >(val2);
5609 if (arg1) (arg1)->x = arg2;
5610
5611 resultobj = SWIG_Py_Void();
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5619 PyObject *resultobj = 0;
5620 wxPoint *arg1 = (wxPoint *) 0 ;
5621 int result;
5622 void *argp1 = 0 ;
5623 int res1 = 0 ;
5624 PyObject *swig_obj[1] ;
5625
5626 if (!args) SWIG_fail;
5627 swig_obj[0] = args;
5628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5629 if (!SWIG_IsOK(res1)) {
5630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5631 }
5632 arg1 = reinterpret_cast< wxPoint * >(argp1);
5633 result = (int) ((arg1)->x);
5634 resultobj = SWIG_From_int(static_cast< int >(result));
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 PyObject *resultobj = 0;
5643 wxPoint *arg1 = (wxPoint *) 0 ;
5644 int arg2 ;
5645 void *argp1 = 0 ;
5646 int res1 = 0 ;
5647 int val2 ;
5648 int ecode2 = 0 ;
5649 PyObject *swig_obj[2] ;
5650
5651 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5658 if (!SWIG_IsOK(ecode2)) {
5659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5660 }
5661 arg2 = static_cast< int >(val2);
5662 if (arg1) (arg1)->y = arg2;
5663
5664 resultobj = SWIG_Py_Void();
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672 PyObject *resultobj = 0;
5673 wxPoint *arg1 = (wxPoint *) 0 ;
5674 int result;
5675 void *argp1 = 0 ;
5676 int res1 = 0 ;
5677 PyObject *swig_obj[1] ;
5678
5679 if (!args) SWIG_fail;
5680 swig_obj[0] = args;
5681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5684 }
5685 arg1 = reinterpret_cast< wxPoint * >(argp1);
5686 result = (int) ((arg1)->y);
5687 resultobj = SWIG_From_int(static_cast< int >(result));
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 int arg1 = (int) 0 ;
5697 int arg2 = (int) 0 ;
5698 wxPoint *result = 0 ;
5699 int val1 ;
5700 int ecode1 = 0 ;
5701 int val2 ;
5702 int ecode2 = 0 ;
5703 PyObject * obj0 = 0 ;
5704 PyObject * obj1 = 0 ;
5705 char * kwnames[] = {
5706 (char *) "x",(char *) "y", NULL
5707 };
5708
5709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5710 if (obj0) {
5711 ecode1 = SWIG_AsVal_int(obj0, &val1);
5712 if (!SWIG_IsOK(ecode1)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5714 }
5715 arg1 = static_cast< int >(val1);
5716 }
5717 if (obj1) {
5718 ecode2 = SWIG_AsVal_int(obj1, &val2);
5719 if (!SWIG_IsOK(ecode2)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5721 }
5722 arg2 = static_cast< int >(val2);
5723 }
5724 {
5725 PyThreadState* __tstate = wxPyBeginAllowThreads();
5726 result = (wxPoint *)new wxPoint(arg1,arg2);
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 PyObject *swig_obj[1] ;
5743
5744 if (!args) SWIG_fail;
5745 swig_obj[0] = args;
5746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5749 }
5750 arg1 = reinterpret_cast< wxPoint * >(argp1);
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 delete arg1;
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 resultobj = SWIG_Py_Void();
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj = 0;
5767 wxPoint *arg1 = (wxPoint *) 0 ;
5768 PyObject *arg2 = (PyObject *) 0 ;
5769 bool result;
5770 void *argp1 = 0 ;
5771 int res1 = 0 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char * kwnames[] = {
5775 (char *) "self",(char *) "other", NULL
5776 };
5777
5778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",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___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 arg2 = obj1;
5785 {
5786 result = (bool)wxPoint___eq__(arg1,arg2);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 {
5790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5791 }
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj = 0;
5800 wxPoint *arg1 = (wxPoint *) 0 ;
5801 PyObject *arg2 = (PyObject *) 0 ;
5802 bool result;
5803 void *argp1 = 0 ;
5804 int res1 = 0 ;
5805 PyObject * obj0 = 0 ;
5806 PyObject * obj1 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "self",(char *) "other", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5813 if (!SWIG_IsOK(res1)) {
5814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5815 }
5816 arg1 = reinterpret_cast< wxPoint * >(argp1);
5817 arg2 = obj1;
5818 {
5819 result = (bool)wxPoint___ne__(arg1,arg2);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj = 0;
5833 wxPoint *arg1 = (wxPoint *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint result;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 wxPoint temp2 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "self",(char *) "pt", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5847 if (!SWIG_IsOK(res1)) {
5848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5849 }
5850 arg1 = reinterpret_cast< wxPoint * >(argp1);
5851 {
5852 arg2 = &temp2;
5853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5854 }
5855 {
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (arg1)->operator +((wxPoint const &)*arg2);
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxPoint *arg1 = (wxPoint *) 0 ;
5871 wxPoint *arg2 = 0 ;
5872 wxPoint result;
5873 void *argp1 = 0 ;
5874 int res1 = 0 ;
5875 wxPoint temp2 ;
5876 PyObject * obj0 = 0 ;
5877 PyObject * obj1 = 0 ;
5878 char * kwnames[] = {
5879 (char *) "self",(char *) "pt", NULL
5880 };
5881
5882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5884 if (!SWIG_IsOK(res1)) {
5885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5886 }
5887 arg1 = reinterpret_cast< wxPoint * >(argp1);
5888 {
5889 arg2 = &temp2;
5890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5891 }
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (arg1)->operator -((wxPoint const &)*arg2);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj = 0;
5907 wxPoint *arg1 = (wxPoint *) 0 ;
5908 wxPoint *arg2 = 0 ;
5909 wxPoint *result = 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 wxPoint temp2 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char * kwnames[] = {
5916 (char *) "self",(char *) "pt", NULL
5917 };
5918
5919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5921 if (!SWIG_IsOK(res1)) {
5922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5923 }
5924 arg1 = reinterpret_cast< wxPoint * >(argp1);
5925 {
5926 arg2 = &temp2;
5927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5928 }
5929 {
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 {
5932 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5933 result = (wxPoint *) &_result_ref;
5934 }
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 wxPoint *arg2 = 0 ;
5949 wxPoint *result = 0 ;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
5952 wxPoint temp2 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "pt", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 {
5966 arg2 = &temp2;
5967 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5968 }
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 {
5972 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5973 result = (wxPoint *) &_result_ref;
5974 }
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj = 0;
5987 wxPoint *arg1 = (wxPoint *) 0 ;
5988 long arg2 ;
5989 long arg3 ;
5990 void *argp1 = 0 ;
5991 int res1 = 0 ;
5992 long val2 ;
5993 int ecode2 = 0 ;
5994 long val3 ;
5995 int ecode3 = 0 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 PyObject * obj2 = 0 ;
5999 char * kwnames[] = {
6000 (char *) "self",(char *) "x",(char *) "y", NULL
6001 };
6002
6003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6005 if (!SWIG_IsOK(res1)) {
6006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6007 }
6008 arg1 = reinterpret_cast< wxPoint * >(argp1);
6009 ecode2 = SWIG_AsVal_long(obj1, &val2);
6010 if (!SWIG_IsOK(ecode2)) {
6011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6012 }
6013 arg2 = static_cast< long >(val2);
6014 ecode3 = SWIG_AsVal_long(obj2, &val3);
6015 if (!SWIG_IsOK(ecode3)) {
6016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6017 }
6018 arg3 = static_cast< long >(val3);
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 wxPoint_Set(arg1,arg2,arg3);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 resultobj = SWIG_Py_Void();
6026 return resultobj;
6027 fail:
6028 return NULL;
6029 }
6030
6031
6032 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6033 PyObject *resultobj = 0;
6034 wxPoint *arg1 = (wxPoint *) 0 ;
6035 PyObject *result = 0 ;
6036 void *argp1 = 0 ;
6037 int res1 = 0 ;
6038 PyObject *swig_obj[1] ;
6039
6040 if (!args) SWIG_fail;
6041 swig_obj[0] = args;
6042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6043 if (!SWIG_IsOK(res1)) {
6044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6045 }
6046 arg1 = reinterpret_cast< wxPoint * >(argp1);
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (PyObject *)wxPoint_Get(arg1);
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 resultobj = result;
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6061 PyObject *obj;
6062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6064 return SWIG_Py_Void();
6065 }
6066
6067 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6068 return SWIG_Python_InitShadowInstance(args);
6069 }
6070
6071 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 int arg1 = (int) 0 ;
6074 int arg2 = (int) 0 ;
6075 int arg3 = (int) 0 ;
6076 int arg4 = (int) 0 ;
6077 wxRect *result = 0 ;
6078 int val1 ;
6079 int ecode1 = 0 ;
6080 int val2 ;
6081 int ecode2 = 0 ;
6082 int val3 ;
6083 int ecode3 = 0 ;
6084 int val4 ;
6085 int ecode4 = 0 ;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 PyObject * obj3 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6095 if (obj0) {
6096 ecode1 = SWIG_AsVal_int(obj0, &val1);
6097 if (!SWIG_IsOK(ecode1)) {
6098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6099 }
6100 arg1 = static_cast< int >(val1);
6101 }
6102 if (obj1) {
6103 ecode2 = SWIG_AsVal_int(obj1, &val2);
6104 if (!SWIG_IsOK(ecode2)) {
6105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6106 }
6107 arg2 = static_cast< int >(val2);
6108 }
6109 if (obj2) {
6110 ecode3 = SWIG_AsVal_int(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6113 }
6114 arg3 = static_cast< int >(val3);
6115 }
6116 if (obj3) {
6117 ecode4 = SWIG_AsVal_int(obj3, &val4);
6118 if (!SWIG_IsOK(ecode4)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6120 }
6121 arg4 = static_cast< int >(val4);
6122 }
6123 {
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj = 0;
6138 wxPoint *arg1 = 0 ;
6139 wxPoint *arg2 = 0 ;
6140 wxRect *result = 0 ;
6141 wxPoint temp1 ;
6142 wxPoint temp2 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "topLeft",(char *) "bottomRight", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6150 {
6151 arg1 = &temp1;
6152 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6153 }
6154 {
6155 arg2 = &temp2;
6156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj = 0;
6173 wxPoint *arg1 = 0 ;
6174 wxSize *arg2 = 0 ;
6175 wxRect *result = 0 ;
6176 wxPoint temp1 ;
6177 wxSize temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 char * kwnames[] = {
6181 (char *) "pos",(char *) "size", NULL
6182 };
6183
6184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6185 {
6186 arg1 = &temp1;
6187 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6188 }
6189 {
6190 arg2 = &temp2;
6191 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6192 }
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxSize *arg1 = 0 ;
6209 wxRect *result = 0 ;
6210 wxSize temp1 ;
6211 PyObject * obj0 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "size", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6217 {
6218 arg1 = &temp1;
6219 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6220 }
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6224 wxPyEndAllowThreads(__tstate);
6225 if (PyErr_Occurred()) SWIG_fail;
6226 }
6227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6235 PyObject *resultobj = 0;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 void *argp1 = 0 ;
6238 int res1 = 0 ;
6239 PyObject *swig_obj[1] ;
6240
6241 if (!args) SWIG_fail;
6242 swig_obj[0] = args;
6243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6246 }
6247 arg1 = reinterpret_cast< wxRect * >(argp1);
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 delete arg1;
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 resultobj = SWIG_Py_Void();
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6263 PyObject *resultobj = 0;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int result;
6266 void *argp1 = 0 ;
6267 int res1 = 0 ;
6268 PyObject *swig_obj[1] ;
6269
6270 if (!args) SWIG_fail;
6271 swig_obj[0] = args;
6272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6273 if (!SWIG_IsOK(res1)) {
6274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6275 }
6276 arg1 = reinterpret_cast< wxRect * >(argp1);
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (int)((wxRect const *)arg1)->GetX();
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 resultobj = SWIG_From_int(static_cast< int >(result));
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj = 0;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int arg2 ;
6294 void *argp1 = 0 ;
6295 int res1 = 0 ;
6296 int val2 ;
6297 int ecode2 = 0 ;
6298 PyObject * obj0 = 0 ;
6299 PyObject * obj1 = 0 ;
6300 char * kwnames[] = {
6301 (char *) "self",(char *) "x", NULL
6302 };
6303
6304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6306 if (!SWIG_IsOK(res1)) {
6307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6308 }
6309 arg1 = reinterpret_cast< wxRect * >(argp1);
6310 ecode2 = SWIG_AsVal_int(obj1, &val2);
6311 if (!SWIG_IsOK(ecode2)) {
6312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6313 }
6314 arg2 = static_cast< int >(val2);
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 (arg1)->SetX(arg2);
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_Py_Void();
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6329 PyObject *resultobj = 0;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 int result;
6332 void *argp1 = 0 ;
6333 int res1 = 0 ;
6334 PyObject *swig_obj[1] ;
6335
6336 if (!args) SWIG_fail;
6337 swig_obj[0] = args;
6338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6339 if (!SWIG_IsOK(res1)) {
6340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6341 }
6342 arg1 = reinterpret_cast< wxRect * >(argp1);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (int)(arg1)->GetY();
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_From_int(static_cast< int >(result));
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 int arg2 ;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 int val2 ;
6363 int ecode2 = 0 ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 char * kwnames[] = {
6367 (char *) "self",(char *) "y", NULL
6368 };
6369
6370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 ecode2 = SWIG_AsVal_int(obj1, &val2);
6377 if (!SWIG_IsOK(ecode2)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6379 }
6380 arg2 = static_cast< int >(val2);
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 (arg1)->SetY(arg2);
6384 wxPyEndAllowThreads(__tstate);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_Py_Void();
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 int result;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 PyObject *swig_obj[1] ;
6401
6402 if (!args) SWIG_fail;
6403 swig_obj[0] = args;
6404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6405 if (!SWIG_IsOK(res1)) {
6406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6407 }
6408 arg1 = reinterpret_cast< wxRect * >(argp1);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (int)((wxRect const *)arg1)->GetWidth();
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_From_int(static_cast< int >(result));
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj = 0;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 int arg2 ;
6426 void *argp1 = 0 ;
6427 int res1 = 0 ;
6428 int val2 ;
6429 int ecode2 = 0 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char * kwnames[] = {
6433 (char *) "self",(char *) "w", NULL
6434 };
6435
6436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6438 if (!SWIG_IsOK(res1)) {
6439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6440 }
6441 arg1 = reinterpret_cast< wxRect * >(argp1);
6442 ecode2 = SWIG_AsVal_int(obj1, &val2);
6443 if (!SWIG_IsOK(ecode2)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6445 }
6446 arg2 = static_cast< int >(val2);
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 (arg1)->SetWidth(arg2);
6450 wxPyEndAllowThreads(__tstate);
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_Py_Void();
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int result;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 PyObject *swig_obj[1] ;
6467
6468 if (!args) SWIG_fail;
6469 swig_obj[0] = args;
6470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6473 }
6474 arg1 = reinterpret_cast< wxRect * >(argp1);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 result = (int)((wxRect const *)arg1)->GetHeight();
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_From_int(static_cast< int >(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 int val2 ;
6495 int ecode2 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "h", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 ecode2 = SWIG_AsVal_int(obj1, &val2);
6509 if (!SWIG_IsOK(ecode2)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6511 }
6512 arg2 = static_cast< int >(val2);
6513 {
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 (arg1)->SetHeight(arg2);
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_Py_Void();
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 wxRect *arg1 = (wxRect *) 0 ;
6529 wxPoint result;
6530 void *argp1 = 0 ;
6531 int res1 = 0 ;
6532 PyObject *swig_obj[1] ;
6533
6534 if (!args) SWIG_fail;
6535 swig_obj[0] = args;
6536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6539 }
6540 arg1 = reinterpret_cast< wxRect * >(argp1);
6541 {
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 result = ((wxRect const *)arg1)->GetPosition();
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj = 0;
6556 wxRect *arg1 = (wxRect *) 0 ;
6557 wxPoint *arg2 = 0 ;
6558 void *argp1 = 0 ;
6559 int res1 = 0 ;
6560 wxPoint temp2 ;
6561 PyObject * obj0 = 0 ;
6562 PyObject * obj1 = 0 ;
6563 char * kwnames[] = {
6564 (char *) "self",(char *) "p", NULL
6565 };
6566
6567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 arg2 = &temp2;
6575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6576 }
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 (arg1)->SetPosition((wxPoint const &)*arg2);
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 resultobj = SWIG_Py_Void();
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6591 PyObject *resultobj = 0;
6592 wxRect *arg1 = (wxRect *) 0 ;
6593 wxSize result;
6594 void *argp1 = 0 ;
6595 int res1 = 0 ;
6596 PyObject *swig_obj[1] ;
6597
6598 if (!args) SWIG_fail;
6599 swig_obj[0] = args;
6600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6601 if (!SWIG_IsOK(res1)) {
6602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6603 }
6604 arg1 = reinterpret_cast< wxRect * >(argp1);
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = ((wxRect const *)arg1)->GetSize();
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6619 PyObject *resultobj = 0;
6620 wxRect *arg1 = (wxRect *) 0 ;
6621 wxSize *arg2 = 0 ;
6622 void *argp1 = 0 ;
6623 int res1 = 0 ;
6624 wxSize temp2 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 char * kwnames[] = {
6628 (char *) "self",(char *) "s", NULL
6629 };
6630
6631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 arg2 = &temp2;
6639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6640 }
6641 {
6642 PyThreadState* __tstate = wxPyBeginAllowThreads();
6643 (arg1)->SetSize((wxSize const &)*arg2);
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 resultobj = SWIG_Py_Void();
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6655 PyObject *resultobj = 0;
6656 wxRect *arg1 = (wxRect *) 0 ;
6657 bool result;
6658 void *argp1 = 0 ;
6659 int res1 = 0 ;
6660 PyObject *swig_obj[1] ;
6661
6662 if (!args) SWIG_fail;
6663 swig_obj[0] = args;
6664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (bool)((wxRect const *)arg1)->IsEmpty();
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 {
6676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6677 }
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685 PyObject *resultobj = 0;
6686 wxRect *arg1 = (wxRect *) 0 ;
6687 wxPoint result;
6688 void *argp1 = 0 ;
6689 int res1 = 0 ;
6690 PyObject *swig_obj[1] ;
6691
6692 if (!args) SWIG_fail;
6693 swig_obj[0] = args;
6694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6695 if (!SWIG_IsOK(res1)) {
6696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6697 }
6698 arg1 = reinterpret_cast< wxRect * >(argp1);
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 result = ((wxRect const *)arg1)->GetTopLeft();
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj = 0;
6714 wxRect *arg1 = (wxRect *) 0 ;
6715 wxPoint *arg2 = 0 ;
6716 void *argp1 = 0 ;
6717 int res1 = 0 ;
6718 wxPoint temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char * kwnames[] = {
6722 (char *) "self",(char *) "p", NULL
6723 };
6724
6725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6727 if (!SWIG_IsOK(res1)) {
6728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6729 }
6730 arg1 = reinterpret_cast< wxRect * >(argp1);
6731 {
6732 arg2 = &temp2;
6733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_Py_Void();
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6749 PyObject *resultobj = 0;
6750 wxRect *arg1 = (wxRect *) 0 ;
6751 wxPoint result;
6752 void *argp1 = 0 ;
6753 int res1 = 0 ;
6754 PyObject *swig_obj[1] ;
6755
6756 if (!args) SWIG_fail;
6757 swig_obj[0] = args;
6758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6759 if (!SWIG_IsOK(res1)) {
6760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6761 }
6762 arg1 = reinterpret_cast< wxRect * >(argp1);
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = ((wxRect const *)arg1)->GetBottomRight();
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj = 0;
6778 wxRect *arg1 = (wxRect *) 0 ;
6779 wxPoint *arg2 = 0 ;
6780 void *argp1 = 0 ;
6781 int res1 = 0 ;
6782 wxPoint temp2 ;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char * kwnames[] = {
6786 (char *) "self",(char *) "p", NULL
6787 };
6788
6789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 arg2 = &temp2;
6797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_Py_Void();
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxRect *arg1 = (wxRect *) 0 ;
6815 int result;
6816 void *argp1 = 0 ;
6817 int res1 = 0 ;
6818 PyObject *swig_obj[1] ;
6819
6820 if (!args) SWIG_fail;
6821 swig_obj[0] = args;
6822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (int)((wxRect const *)arg1)->GetLeft();
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_From_int(static_cast< int >(result));
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 int result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 result = (int)((wxRect const *)arg1)->GetTop();
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_From_int(static_cast< int >(result));
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 int result;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 PyObject *swig_obj[1] ;
6875
6876 if (!args) SWIG_fail;
6877 swig_obj[0] = args;
6878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6879 if (!SWIG_IsOK(res1)) {
6880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6881 }
6882 arg1 = reinterpret_cast< wxRect * >(argp1);
6883 {
6884 PyThreadState* __tstate = wxPyBeginAllowThreads();
6885 result = (int)((wxRect const *)arg1)->GetBottom();
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 resultobj = SWIG_From_int(static_cast< int >(result));
6890 return resultobj;
6891 fail:
6892 return NULL;
6893 }
6894
6895
6896 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6897 PyObject *resultobj = 0;
6898 wxRect *arg1 = (wxRect *) 0 ;
6899 int result;
6900 void *argp1 = 0 ;
6901 int res1 = 0 ;
6902 PyObject *swig_obj[1] ;
6903
6904 if (!args) SWIG_fail;
6905 swig_obj[0] = args;
6906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6907 if (!SWIG_IsOK(res1)) {
6908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6909 }
6910 arg1 = reinterpret_cast< wxRect * >(argp1);
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (int)((wxRect const *)arg1)->GetRight();
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_From_int(static_cast< int >(result));
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj = 0;
6926 wxRect *arg1 = (wxRect *) 0 ;
6927 int arg2 ;
6928 void *argp1 = 0 ;
6929 int res1 = 0 ;
6930 int val2 ;
6931 int ecode2 = 0 ;
6932 PyObject * obj0 = 0 ;
6933 PyObject * obj1 = 0 ;
6934 char * kwnames[] = {
6935 (char *) "self",(char *) "left", NULL
6936 };
6937
6938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6940 if (!SWIG_IsOK(res1)) {
6941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6942 }
6943 arg1 = reinterpret_cast< wxRect * >(argp1);
6944 ecode2 = SWIG_AsVal_int(obj1, &val2);
6945 if (!SWIG_IsOK(ecode2)) {
6946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6947 }
6948 arg2 = static_cast< int >(val2);
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 (arg1)->SetLeft(arg2);
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj = 0;
6964 wxRect *arg1 = (wxRect *) 0 ;
6965 int arg2 ;
6966 void *argp1 = 0 ;
6967 int res1 = 0 ;
6968 int val2 ;
6969 int ecode2 = 0 ;
6970 PyObject * obj0 = 0 ;
6971 PyObject * obj1 = 0 ;
6972 char * kwnames[] = {
6973 (char *) "self",(char *) "right", NULL
6974 };
6975
6976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6978 if (!SWIG_IsOK(res1)) {
6979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6980 }
6981 arg1 = reinterpret_cast< wxRect * >(argp1);
6982 ecode2 = SWIG_AsVal_int(obj1, &val2);
6983 if (!SWIG_IsOK(ecode2)) {
6984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6985 }
6986 arg2 = static_cast< int >(val2);
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 (arg1)->SetRight(arg2);
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_Py_Void();
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 int arg2 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 int val2 ;
7007 int ecode2 = 0 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 char * kwnames[] = {
7011 (char *) "self",(char *) "top", NULL
7012 };
7013
7014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7016 if (!SWIG_IsOK(res1)) {
7017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7018 }
7019 arg1 = reinterpret_cast< wxRect * >(argp1);
7020 ecode2 = SWIG_AsVal_int(obj1, &val2);
7021 if (!SWIG_IsOK(ecode2)) {
7022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7023 }
7024 arg2 = static_cast< int >(val2);
7025 {
7026 PyThreadState* __tstate = wxPyBeginAllowThreads();
7027 (arg1)->SetTop(arg2);
7028 wxPyEndAllowThreads(__tstate);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_Py_Void();
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj = 0;
7040 wxRect *arg1 = (wxRect *) 0 ;
7041 int arg2 ;
7042 void *argp1 = 0 ;
7043 int res1 = 0 ;
7044 int val2 ;
7045 int ecode2 = 0 ;
7046 PyObject * obj0 = 0 ;
7047 PyObject * obj1 = 0 ;
7048 char * kwnames[] = {
7049 (char *) "self",(char *) "bottom", NULL
7050 };
7051
7052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7054 if (!SWIG_IsOK(res1)) {
7055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7056 }
7057 arg1 = reinterpret_cast< wxRect * >(argp1);
7058 ecode2 = SWIG_AsVal_int(obj1, &val2);
7059 if (!SWIG_IsOK(ecode2)) {
7060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7061 }
7062 arg2 = static_cast< int >(val2);
7063 {
7064 PyThreadState* __tstate = wxPyBeginAllowThreads();
7065 (arg1)->SetBottom(arg2);
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_Py_Void();
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int arg2 ;
7080 int arg3 ;
7081 wxRect *result = 0 ;
7082 void *argp1 = 0 ;
7083 int res1 = 0 ;
7084 int val2 ;
7085 int ecode2 = 0 ;
7086 int val3 ;
7087 int ecode3 = 0 ;
7088 PyObject * obj0 = 0 ;
7089 PyObject * obj1 = 0 ;
7090 PyObject * obj2 = 0 ;
7091 char * kwnames[] = {
7092 (char *) "self",(char *) "dx",(char *) "dy", NULL
7093 };
7094
7095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 ecode2 = SWIG_AsVal_int(obj1, &val2);
7102 if (!SWIG_IsOK(ecode2)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7104 }
7105 arg2 = static_cast< int >(val2);
7106 ecode3 = SWIG_AsVal_int(obj2, &val3);
7107 if (!SWIG_IsOK(ecode3)) {
7108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7109 }
7110 arg3 = static_cast< int >(val3);
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 {
7114 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7115 result = (wxRect *) &_result_ref;
7116 }
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 int arg3 ;
7132 wxRect *result = 0 ;
7133 void *argp1 = 0 ;
7134 int res1 = 0 ;
7135 int val2 ;
7136 int ecode2 = 0 ;
7137 int val3 ;
7138 int ecode3 = 0 ;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 PyObject * obj2 = 0 ;
7142 char * kwnames[] = {
7143 (char *) "self",(char *) "dx",(char *) "dy", NULL
7144 };
7145
7146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7148 if (!SWIG_IsOK(res1)) {
7149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7150 }
7151 arg1 = reinterpret_cast< wxRect * >(argp1);
7152 ecode2 = SWIG_AsVal_int(obj1, &val2);
7153 if (!SWIG_IsOK(ecode2)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7155 }
7156 arg2 = static_cast< int >(val2);
7157 ecode3 = SWIG_AsVal_int(obj2, &val3);
7158 if (!SWIG_IsOK(ecode3)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7160 }
7161 arg3 = static_cast< int >(val3);
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 {
7165 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7166 result = (wxRect *) &_result_ref;
7167 }
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj = 0;
7180 wxRect *arg1 = (wxRect *) 0 ;
7181 int arg2 ;
7182 int arg3 ;
7183 void *argp1 = 0 ;
7184 int res1 = 0 ;
7185 int val2 ;
7186 int ecode2 = 0 ;
7187 int val3 ;
7188 int ecode3 = 0 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 PyObject * obj2 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "dx",(char *) "dy", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 ecode2 = SWIG_AsVal_int(obj1, &val2);
7203 if (!SWIG_IsOK(ecode2)) {
7204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7205 }
7206 arg2 = static_cast< int >(val2);
7207 ecode3 = SWIG_AsVal_int(obj2, &val3);
7208 if (!SWIG_IsOK(ecode3)) {
7209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7210 }
7211 arg3 = static_cast< int >(val3);
7212 {
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 (arg1)->Offset(arg2,arg3);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 resultobj = SWIG_Py_Void();
7219 return resultobj;
7220 fail:
7221 return NULL;
7222 }
7223
7224
7225 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7226 PyObject *resultobj = 0;
7227 wxRect *arg1 = (wxRect *) 0 ;
7228 wxPoint *arg2 = 0 ;
7229 void *argp1 = 0 ;
7230 int res1 = 0 ;
7231 wxPoint temp2 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "pt", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 {
7245 arg2 = &temp2;
7246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7247 }
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 (arg1)->Offset((wxPoint const &)*arg2);
7251 wxPyEndAllowThreads(__tstate);
7252 if (PyErr_Occurred()) SWIG_fail;
7253 }
7254 resultobj = SWIG_Py_Void();
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxRect *arg1 = (wxRect *) 0 ;
7264 wxRect *arg2 = 0 ;
7265 wxRect result;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 wxRect temp2 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "rect", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 {
7282 arg2 = &temp2;
7283 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7284 }
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (arg1)->Intersect((wxRect const &)*arg2);
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 wxRect *arg2 = 0 ;
7302 wxRect result;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 wxRect temp2 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "rect", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7316 }
7317 arg1 = reinterpret_cast< wxRect * >(argp1);
7318 {
7319 arg2 = &temp2;
7320 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (arg1)->Union((wxRect const &)*arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 wxRect *arg2 = 0 ;
7339 wxRect result;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 wxRect temp2 ;
7343 PyObject * obj0 = 0 ;
7344 PyObject * obj1 = 0 ;
7345 char * kwnames[] = {
7346 (char *) "self",(char *) "rect", NULL
7347 };
7348
7349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7353 }
7354 arg1 = reinterpret_cast< wxRect * >(argp1);
7355 {
7356 arg2 = &temp2;
7357 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7358 }
7359 {
7360 PyThreadState* __tstate = wxPyBeginAllowThreads();
7361 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj = 0;
7374 wxRect *arg1 = (wxRect *) 0 ;
7375 wxRect *arg2 = 0 ;
7376 wxRect *result = 0 ;
7377 void *argp1 = 0 ;
7378 int res1 = 0 ;
7379 wxRect temp2 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "rect", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 {
7393 arg2 = &temp2;
7394 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7395 }
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 {
7399 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7400 result = (wxRect *) &_result_ref;
7401 }
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj = 0;
7414 wxRect *arg1 = (wxRect *) 0 ;
7415 PyObject *arg2 = (PyObject *) 0 ;
7416 bool result;
7417 void *argp1 = 0 ;
7418 int res1 = 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 char * kwnames[] = {
7422 (char *) "self",(char *) "other", NULL
7423 };
7424
7425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7427 if (!SWIG_IsOK(res1)) {
7428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7429 }
7430 arg1 = reinterpret_cast< wxRect * >(argp1);
7431 arg2 = obj1;
7432 {
7433 result = (bool)wxRect___eq__(arg1,arg2);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7438 }
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj = 0;
7447 wxRect *arg1 = (wxRect *) 0 ;
7448 PyObject *arg2 = (PyObject *) 0 ;
7449 bool result;
7450 void *argp1 = 0 ;
7451 int res1 = 0 ;
7452 PyObject * obj0 = 0 ;
7453 PyObject * obj1 = 0 ;
7454 char * kwnames[] = {
7455 (char *) "self",(char *) "other", NULL
7456 };
7457
7458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7460 if (!SWIG_IsOK(res1)) {
7461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7462 }
7463 arg1 = reinterpret_cast< wxRect * >(argp1);
7464 arg2 = obj1;
7465 {
7466 result = (bool)wxRect___ne__(arg1,arg2);
7467 if (PyErr_Occurred()) SWIG_fail;
7468 }
7469 {
7470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7471 }
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj = 0;
7480 wxRect *arg1 = (wxRect *) 0 ;
7481 int arg2 ;
7482 int arg3 ;
7483 bool result;
7484 void *argp1 = 0 ;
7485 int res1 = 0 ;
7486 int val2 ;
7487 int ecode2 = 0 ;
7488 int val3 ;
7489 int ecode3 = 0 ;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 PyObject * obj2 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "x",(char *) "y", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 ecode2 = SWIG_AsVal_int(obj1, &val2);
7504 if (!SWIG_IsOK(ecode2)) {
7505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7506 }
7507 arg2 = static_cast< int >(val2);
7508 ecode3 = SWIG_AsVal_int(obj2, &val3);
7509 if (!SWIG_IsOK(ecode3)) {
7510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7511 }
7512 arg3 = static_cast< int >(val3);
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7516 wxPyEndAllowThreads(__tstate);
7517 if (PyErr_Occurred()) SWIG_fail;
7518 }
7519 {
7520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7521 }
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxRect *arg1 = (wxRect *) 0 ;
7531 wxPoint *arg2 = 0 ;
7532 bool result;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 wxPoint temp2 ;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char * kwnames[] = {
7539 (char *) "self",(char *) "pt", NULL
7540 };
7541
7542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7544 if (!SWIG_IsOK(res1)) {
7545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7546 }
7547 arg1 = reinterpret_cast< wxRect * >(argp1);
7548 {
7549 arg2 = &temp2;
7550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7551 }
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 {
7559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7560 }
7561 return resultobj;
7562 fail:
7563 return NULL;
7564 }
7565
7566
7567 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7568 PyObject *resultobj = 0;
7569 wxRect *arg1 = (wxRect *) 0 ;
7570 wxRect *arg2 = 0 ;
7571 bool result;
7572 void *argp1 = 0 ;
7573 int res1 = 0 ;
7574 wxRect temp2 ;
7575 PyObject * obj0 = 0 ;
7576 PyObject * obj1 = 0 ;
7577 char * kwnames[] = {
7578 (char *) "self",(char *) "rect", NULL
7579 };
7580
7581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7583 if (!SWIG_IsOK(res1)) {
7584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7585 }
7586 arg1 = reinterpret_cast< wxRect * >(argp1);
7587 {
7588 arg2 = &temp2;
7589 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7590 }
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj = 0;
7608 wxRect *arg1 = (wxRect *) 0 ;
7609 wxRect *arg2 = 0 ;
7610 bool result;
7611 void *argp1 = 0 ;
7612 int res1 = 0 ;
7613 wxRect temp2 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "rect", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 {
7637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7638 }
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj = 0;
7647 wxRect *arg1 = (wxRect *) 0 ;
7648 wxRect *arg2 = 0 ;
7649 int arg3 = (int) wxBOTH ;
7650 wxRect result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 wxRect temp2 ;
7654 int val3 ;
7655 int ecode3 = 0 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 PyObject * obj2 = 0 ;
7659 char * kwnames[] = {
7660 (char *) "self",(char *) "r",(char *) "dir", NULL
7661 };
7662
7663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7665 if (!SWIG_IsOK(res1)) {
7666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7667 }
7668 arg1 = reinterpret_cast< wxRect * >(argp1);
7669 {
7670 arg2 = &temp2;
7671 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7672 }
7673 if (obj2) {
7674 ecode3 = SWIG_AsVal_int(obj2, &val3);
7675 if (!SWIG_IsOK(ecode3)) {
7676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7677 }
7678 arg3 = static_cast< int >(val3);
7679 }
7680 {
7681 PyThreadState* __tstate = wxPyBeginAllowThreads();
7682 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 SWIGINTERN PyObject *_wrap_Rect_x_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_x_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_x_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_x_set" "', expected argument " "2"" of type '" "int""'");
7712 }
7713 arg2 = static_cast< int >(val2);
7714 if (arg1) (arg1)->x = arg2;
7715
7716 resultobj = SWIG_Py_Void();
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_x_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_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 result = (int) ((arg1)->x);
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_y_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_y_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_y_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_y_set" "', expected argument " "2"" of type '" "int""'");
7765 }
7766 arg2 = static_cast< int >(val2);
7767 if (arg1) (arg1)->y = arg2;
7768
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_y_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_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7789 }
7790 arg1 = reinterpret_cast< wxRect * >(argp1);
7791 result = (int) ((arg1)->y);
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_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 int arg2 ;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 int val2 ;
7806 int ecode2 = 0 ;
7807 PyObject *swig_obj[2] ;
7808
7809 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7811 if (!SWIG_IsOK(res1)) {
7812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7813 }
7814 arg1 = reinterpret_cast< wxRect * >(argp1);
7815 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7816 if (!SWIG_IsOK(ecode2)) {
7817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7818 }
7819 arg2 = static_cast< int >(val2);
7820 if (arg1) (arg1)->width = arg2;
7821
7822 resultobj = SWIG_Py_Void();
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830 PyObject *resultobj = 0;
7831 wxRect *arg1 = (wxRect *) 0 ;
7832 int result;
7833 void *argp1 = 0 ;
7834 int res1 = 0 ;
7835 PyObject *swig_obj[1] ;
7836
7837 if (!args) SWIG_fail;
7838 swig_obj[0] = args;
7839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7840 if (!SWIG_IsOK(res1)) {
7841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7842 }
7843 arg1 = reinterpret_cast< wxRect * >(argp1);
7844 result = (int) ((arg1)->width);
7845 resultobj = SWIG_From_int(static_cast< int >(result));
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7853 PyObject *resultobj = 0;
7854 wxRect *arg1 = (wxRect *) 0 ;
7855 int arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 int val2 ;
7859 int ecode2 = 0 ;
7860 PyObject *swig_obj[2] ;
7861
7862 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7864 if (!SWIG_IsOK(res1)) {
7865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7866 }
7867 arg1 = reinterpret_cast< wxRect * >(argp1);
7868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7869 if (!SWIG_IsOK(ecode2)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7871 }
7872 arg2 = static_cast< int >(val2);
7873 if (arg1) (arg1)->height = arg2;
7874
7875 resultobj = SWIG_Py_Void();
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7883 PyObject *resultobj = 0;
7884 wxRect *arg1 = (wxRect *) 0 ;
7885 int result;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 PyObject *swig_obj[1] ;
7889
7890 if (!args) SWIG_fail;
7891 swig_obj[0] = args;
7892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7893 if (!SWIG_IsOK(res1)) {
7894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7895 }
7896 arg1 = reinterpret_cast< wxRect * >(argp1);
7897 result = (int) ((arg1)->height);
7898 resultobj = SWIG_From_int(static_cast< int >(result));
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj = 0;
7907 wxRect *arg1 = (wxRect *) 0 ;
7908 int arg2 = (int) 0 ;
7909 int arg3 = (int) 0 ;
7910 int arg4 = (int) 0 ;
7911 int arg5 = (int) 0 ;
7912 void *argp1 = 0 ;
7913 int res1 = 0 ;
7914 int val2 ;
7915 int ecode2 = 0 ;
7916 int val3 ;
7917 int ecode3 = 0 ;
7918 int val4 ;
7919 int ecode4 = 0 ;
7920 int val5 ;
7921 int ecode5 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 PyObject * obj2 = 0 ;
7925 PyObject * obj3 = 0 ;
7926 PyObject * obj4 = 0 ;
7927 char * kwnames[] = {
7928 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7929 };
7930
7931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7935 }
7936 arg1 = reinterpret_cast< wxRect * >(argp1);
7937 if (obj1) {
7938 ecode2 = SWIG_AsVal_int(obj1, &val2);
7939 if (!SWIG_IsOK(ecode2)) {
7940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7941 }
7942 arg2 = static_cast< int >(val2);
7943 }
7944 if (obj2) {
7945 ecode3 = SWIG_AsVal_int(obj2, &val3);
7946 if (!SWIG_IsOK(ecode3)) {
7947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7948 }
7949 arg3 = static_cast< int >(val3);
7950 }
7951 if (obj3) {
7952 ecode4 = SWIG_AsVal_int(obj3, &val4);
7953 if (!SWIG_IsOK(ecode4)) {
7954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7955 }
7956 arg4 = static_cast< int >(val4);
7957 }
7958 if (obj4) {
7959 ecode5 = SWIG_AsVal_int(obj4, &val5);
7960 if (!SWIG_IsOK(ecode5)) {
7961 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7962 }
7963 arg5 = static_cast< int >(val5);
7964 }
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 PyObject *resultobj = 0;
7980 wxRect *arg1 = (wxRect *) 0 ;
7981 PyObject *result = 0 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 PyObject *swig_obj[1] ;
7985
7986 if (!args) SWIG_fail;
7987 swig_obj[0] = args;
7988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7989 if (!SWIG_IsOK(res1)) {
7990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7991 }
7992 arg1 = reinterpret_cast< wxRect * >(argp1);
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 result = (PyObject *)wxRect_Get(arg1);
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 resultobj = result;
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *obj;
8008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8009 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8010 return SWIG_Py_Void();
8011 }
8012
8013 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8014 return SWIG_Python_InitShadowInstance(args);
8015 }
8016
8017 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj = 0;
8019 wxRect *arg1 = (wxRect *) 0 ;
8020 wxRect *arg2 = (wxRect *) 0 ;
8021 PyObject *result = 0 ;
8022 void *argp1 = 0 ;
8023 int res1 = 0 ;
8024 void *argp2 = 0 ;
8025 int res2 = 0 ;
8026 PyObject * obj0 = 0 ;
8027 PyObject * obj1 = 0 ;
8028 char * kwnames[] = {
8029 (char *) "r1",(char *) "r2", NULL
8030 };
8031
8032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8036 }
8037 arg1 = reinterpret_cast< wxRect * >(argp1);
8038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8039 if (!SWIG_IsOK(res2)) {
8040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8041 }
8042 arg2 = reinterpret_cast< wxRect * >(argp2);
8043 {
8044 if (!wxPyCheckForApp()) SWIG_fail;
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (PyObject *)wxIntersectRect(arg1,arg2);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = result;
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 double arg1 = (double) 0.0 ;
8060 double arg2 = (double) 0.0 ;
8061 wxPoint2D *result = 0 ;
8062 double val1 ;
8063 int ecode1 = 0 ;
8064 double val2 ;
8065 int ecode2 = 0 ;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 char * kwnames[] = {
8069 (char *) "x",(char *) "y", NULL
8070 };
8071
8072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8073 if (obj0) {
8074 ecode1 = SWIG_AsVal_double(obj0, &val1);
8075 if (!SWIG_IsOK(ecode1)) {
8076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8077 }
8078 arg1 = static_cast< double >(val1);
8079 }
8080 if (obj1) {
8081 ecode2 = SWIG_AsVal_double(obj1, &val2);
8082 if (!SWIG_IsOK(ecode2)) {
8083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8084 }
8085 arg2 = static_cast< double >(val2);
8086 }
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj = 0;
8102 wxPoint2D *arg1 = 0 ;
8103 wxPoint2D *result = 0 ;
8104 wxPoint2D temp1 ;
8105 PyObject * obj0 = 0 ;
8106 char * kwnames[] = {
8107 (char *) "pt", NULL
8108 };
8109
8110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8111 {
8112 arg1 = &temp1;
8113 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8114 }
8115 {
8116 PyThreadState* __tstate = wxPyBeginAllowThreads();
8117 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj = 0;
8130 wxPoint *arg1 = 0 ;
8131 wxPoint2D *result = 0 ;
8132 wxPoint temp1 ;
8133 PyObject * obj0 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "pt", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8139 {
8140 arg1 = &temp1;
8141 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8142 }
8143 {
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *resultobj = 0;
8158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8159 int *arg2 = (int *) 0 ;
8160 int *arg3 = (int *) 0 ;
8161 void *argp1 = 0 ;
8162 int res1 = 0 ;
8163 int temp2 ;
8164 int res2 = SWIG_TMPOBJ ;
8165 int temp3 ;
8166 int res3 = SWIG_TMPOBJ ;
8167 PyObject *swig_obj[1] ;
8168
8169 arg2 = &temp2;
8170 arg3 = &temp3;
8171 if (!args) SWIG_fail;
8172 swig_obj[0] = args;
8173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8174 if (!SWIG_IsOK(res1)) {
8175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8176 }
8177 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8178 {
8179 PyThreadState* __tstate = wxPyBeginAllowThreads();
8180 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8181 wxPyEndAllowThreads(__tstate);
8182 if (PyErr_Occurred()) SWIG_fail;
8183 }
8184 resultobj = SWIG_Py_Void();
8185 if (SWIG_IsTmpObj(res2)) {
8186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8187 } else {
8188 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8190 }
8191 if (SWIG_IsTmpObj(res3)) {
8192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8193 } else {
8194 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8196 }
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 PyObject *resultobj = 0;
8205 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8206 int *arg2 = (int *) 0 ;
8207 int *arg3 = (int *) 0 ;
8208 void *argp1 = 0 ;
8209 int res1 = 0 ;
8210 int temp2 ;
8211 int res2 = SWIG_TMPOBJ ;
8212 int temp3 ;
8213 int res3 = SWIG_TMPOBJ ;
8214 PyObject *swig_obj[1] ;
8215
8216 arg2 = &temp2;
8217 arg3 = &temp3;
8218 if (!args) SWIG_fail;
8219 swig_obj[0] = args;
8220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8223 }
8224 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8228 wxPyEndAllowThreads(__tstate);
8229 if (PyErr_Occurred()) SWIG_fail;
8230 }
8231 resultobj = SWIG_Py_Void();
8232 if (SWIG_IsTmpObj(res2)) {
8233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8234 } else {
8235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8237 }
8238 if (SWIG_IsTmpObj(res3)) {
8239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8240 } else {
8241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8243 }
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 PyObject *resultobj = 0;
8252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8253 double result;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 PyObject *swig_obj[1] ;
8257
8258 if (!args) SWIG_fail;
8259 swig_obj[0] = args;
8260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8261 if (!SWIG_IsOK(res1)) {
8262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8263 }
8264 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_From_double(static_cast< double >(result));
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8279 PyObject *resultobj = 0;
8280 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8281 double result;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 PyObject *swig_obj[1] ;
8285
8286 if (!args) SWIG_fail;
8287 swig_obj[0] = args;
8288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8289 if (!SWIG_IsOK(res1)) {
8290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8291 }
8292 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8293 {
8294 PyThreadState* __tstate = wxPyBeginAllowThreads();
8295 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 resultobj = SWIG_From_double(static_cast< double >(result));
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj = 0;
8308 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8309 double arg2 ;
8310 void *argp1 = 0 ;
8311 int res1 = 0 ;
8312 double val2 ;
8313 int ecode2 = 0 ;
8314 PyObject * obj0 = 0 ;
8315 PyObject * obj1 = 0 ;
8316 char * kwnames[] = {
8317 (char *) "self",(char *) "length", NULL
8318 };
8319
8320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8324 }
8325 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8326 ecode2 = SWIG_AsVal_double(obj1, &val2);
8327 if (!SWIG_IsOK(ecode2)) {
8328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8329 }
8330 arg2 = static_cast< double >(val2);
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 (arg1)->SetVectorLength(arg2);
8334 wxPyEndAllowThreads(__tstate);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 resultobj = SWIG_Py_Void();
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8347 double arg2 ;
8348 void *argp1 = 0 ;
8349 int res1 = 0 ;
8350 double val2 ;
8351 int ecode2 = 0 ;
8352 PyObject * obj0 = 0 ;
8353 PyObject * obj1 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "self",(char *) "degrees", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8362 }
8363 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8364 ecode2 = SWIG_AsVal_double(obj1, &val2);
8365 if (!SWIG_IsOK(ecode2)) {
8366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8367 }
8368 arg2 = static_cast< double >(val2);
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 (arg1)->SetVectorAngle(arg2);
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 resultobj = SWIG_Py_Void();
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj = 0;
8384 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8385 wxPoint2D *arg2 = 0 ;
8386 double result;
8387 void *argp1 = 0 ;
8388 int res1 = 0 ;
8389 wxPoint2D temp2 ;
8390 PyObject * obj0 = 0 ;
8391 PyObject * obj1 = 0 ;
8392 char * kwnames[] = {
8393 (char *) "self",(char *) "pt", NULL
8394 };
8395
8396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8398 if (!SWIG_IsOK(res1)) {
8399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8400 }
8401 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8402 {
8403 arg2 = &temp2;
8404 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8405 }
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_From_double(static_cast< double >(result));
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj = 0;
8421 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8422 wxPoint2D *arg2 = 0 ;
8423 double result;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 wxPoint2D temp2 ;
8427 PyObject * obj0 = 0 ;
8428 PyObject * obj1 = 0 ;
8429 char * kwnames[] = {
8430 (char *) "self",(char *) "pt", NULL
8431 };
8432
8433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8435 if (!SWIG_IsOK(res1)) {
8436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8437 }
8438 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8439 {
8440 arg2 = &temp2;
8441 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8442 }
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_From_double(static_cast< double >(result));
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 double result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "vec", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 resultobj = SWIG_From_double(static_cast< double >(result));
8487 return resultobj;
8488 fail:
8489 return NULL;
8490 }
8491
8492
8493 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8494 PyObject *resultobj = 0;
8495 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8496 wxPoint2D *arg2 = 0 ;
8497 double result;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 wxPoint2D temp2 ;
8501 PyObject * obj0 = 0 ;
8502 PyObject * obj1 = 0 ;
8503 char * kwnames[] = {
8504 (char *) "self",(char *) "vec", NULL
8505 };
8506
8507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8509 if (!SWIG_IsOK(res1)) {
8510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8511 }
8512 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8513 {
8514 arg2 = &temp2;
8515 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 resultobj = SWIG_From_double(static_cast< double >(result));
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8533 wxPoint2D result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 PyObject *swig_obj[1] ;
8537
8538 if (!args) SWIG_fail;
8539 swig_obj[0] = args;
8540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (arg1)->operator -();
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj = 0;
8560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8561 wxPoint2D *arg2 = 0 ;
8562 wxPoint2D *result = 0 ;
8563 void *argp1 = 0 ;
8564 int res1 = 0 ;
8565 wxPoint2D temp2 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "pt", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8576 }
8577 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8578 {
8579 arg2 = &temp2;
8580 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8581 }
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 {
8585 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8586 result = (wxPoint2D *) &_result_ref;
8587 }
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8601 wxPoint2D *arg2 = 0 ;
8602 wxPoint2D *result = 0 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 wxPoint2D temp2 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "pt", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 {
8619 arg2 = &temp2;
8620 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8621 }
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 {
8625 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8626 result = (wxPoint2D *) &_result_ref;
8627 }
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8632 return resultobj;
8633 fail:
8634 return NULL;
8635 }
8636
8637
8638 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8639 PyObject *resultobj = 0;
8640 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8641 wxPoint2D *arg2 = 0 ;
8642 wxPoint2D *result = 0 ;
8643 void *argp1 = 0 ;
8644 int res1 = 0 ;
8645 wxPoint2D temp2 ;
8646 PyObject * obj0 = 0 ;
8647 PyObject * obj1 = 0 ;
8648 char * kwnames[] = {
8649 (char *) "self",(char *) "pt", NULL
8650 };
8651
8652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8654 if (!SWIG_IsOK(res1)) {
8655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8656 }
8657 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8658 {
8659 arg2 = &temp2;
8660 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8661 }
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 {
8665 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8666 result = (wxPoint2D *) &_result_ref;
8667 }
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 wxPoint2D *arg2 = 0 ;
8682 wxPoint2D *result = 0 ;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 wxPoint2D temp2 ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 char * kwnames[] = {
8689 (char *) "self",(char *) "pt", NULL
8690 };
8691
8692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8696 }
8697 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8698 {
8699 arg2 = &temp2;
8700 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 {
8705 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8706 result = (wxPoint2D *) &_result_ref;
8707 }
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj = 0;
8720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8721 PyObject *arg2 = (PyObject *) 0 ;
8722 bool result;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "other", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8735 }
8736 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8737 arg2 = obj1;
8738 {
8739 result = (bool)wxPoint2D___eq__(arg1,arg2);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 {
8743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8744 }
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj = 0;
8753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8754 PyObject *arg2 = (PyObject *) 0 ;
8755 bool result;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "other", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8768 }
8769 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8770 arg2 = obj1;
8771 {
8772 result = (bool)wxPoint2D___ne__(arg1,arg2);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 {
8776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8777 }
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785 PyObject *resultobj = 0;
8786 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8787 double arg2 ;
8788 void *argp1 = 0 ;
8789 int res1 = 0 ;
8790 double val2 ;
8791 int ecode2 = 0 ;
8792 PyObject *swig_obj[2] ;
8793
8794 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8796 if (!SWIG_IsOK(res1)) {
8797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8798 }
8799 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8800 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8801 if (!SWIG_IsOK(ecode2)) {
8802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8803 }
8804 arg2 = static_cast< double >(val2);
8805 if (arg1) (arg1)->m_x = arg2;
8806
8807 resultobj = SWIG_Py_Void();
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8815 PyObject *resultobj = 0;
8816 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8817 double result;
8818 void *argp1 = 0 ;
8819 int res1 = 0 ;
8820 PyObject *swig_obj[1] ;
8821
8822 if (!args) SWIG_fail;
8823 swig_obj[0] = args;
8824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8825 if (!SWIG_IsOK(res1)) {
8826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8827 }
8828 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8829 result = (double) ((arg1)->m_x);
8830 resultobj = SWIG_From_double(static_cast< double >(result));
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8840 double arg2 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 double val2 ;
8844 int ecode2 = 0 ;
8845 PyObject *swig_obj[2] ;
8846
8847 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8851 }
8852 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8853 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8856 }
8857 arg2 = static_cast< double >(val2);
8858 if (arg1) (arg1)->m_y = arg2;
8859
8860 resultobj = SWIG_Py_Void();
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *resultobj = 0;
8869 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8870 double result;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 PyObject *swig_obj[1] ;
8874
8875 if (!args) SWIG_fail;
8876 swig_obj[0] = args;
8877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8878 if (!SWIG_IsOK(res1)) {
8879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8880 }
8881 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8882 result = (double) ((arg1)->m_y);
8883 resultobj = SWIG_From_double(static_cast< double >(result));
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8893 double arg2 = (double) 0 ;
8894 double arg3 = (double) 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 double val2 ;
8898 int ecode2 = 0 ;
8899 double val3 ;
8900 int ecode3 = 0 ;
8901 PyObject * obj0 = 0 ;
8902 PyObject * obj1 = 0 ;
8903 PyObject * obj2 = 0 ;
8904 char * kwnames[] = {
8905 (char *) "self",(char *) "x",(char *) "y", NULL
8906 };
8907
8908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8912 }
8913 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8914 if (obj1) {
8915 ecode2 = SWIG_AsVal_double(obj1, &val2);
8916 if (!SWIG_IsOK(ecode2)) {
8917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8918 }
8919 arg2 = static_cast< double >(val2);
8920 }
8921 if (obj2) {
8922 ecode3 = SWIG_AsVal_double(obj2, &val3);
8923 if (!SWIG_IsOK(ecode3)) {
8924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8925 }
8926 arg3 = static_cast< double >(val3);
8927 }
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 wxPoint2D_Set(arg1,arg2,arg3);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_Py_Void();
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8944 PyObject *result = 0 ;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 PyObject *swig_obj[1] ;
8948
8949 if (!args) SWIG_fail;
8950 swig_obj[0] = args;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 result = (PyObject *)wxPoint2D_Get(arg1);
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 resultobj = result;
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *obj;
8971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8972 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8973 return SWIG_Py_Void();
8974 }
8975
8976 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8977 return SWIG_Python_InitShadowInstance(args);
8978 }
8979
8980 SWIGINTERN int DefaultPosition_set(PyObject *) {
8981 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8982 return 1;
8983 }
8984
8985
8986 SWIGINTERN PyObject *DefaultPosition_get(void) {
8987 PyObject *pyobj = 0;
8988
8989 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8990 return pyobj;
8991 }
8992
8993
8994 SWIGINTERN int DefaultSize_set(PyObject *) {
8995 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8996 return 1;
8997 }
8998
8999
9000 SWIGINTERN PyObject *DefaultSize_get(void) {
9001 PyObject *pyobj = 0;
9002
9003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9004 return pyobj;
9005 }
9006
9007
9008 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj = 0;
9010 PyObject *arg1 = (PyObject *) 0 ;
9011 wxPyInputStream *result = 0 ;
9012 PyObject * obj0 = 0 ;
9013 char * kwnames[] = {
9014 (char *) "p", NULL
9015 };
9016
9017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9018 arg1 = obj0;
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9026 return resultobj;
9027 fail:
9028 return NULL;
9029 }
9030
9031
9032 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9033 PyObject *resultobj = 0;
9034 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 PyObject *swig_obj[1] ;
9038
9039 if (!args) SWIG_fail;
9040 swig_obj[0] = args;
9041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9044 }
9045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9046 {
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 delete arg1;
9049
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 resultobj = SWIG_Py_Void();
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9061 PyObject *resultobj = 0;
9062 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 PyObject *swig_obj[1] ;
9066
9067 if (!args) SWIG_fail;
9068 swig_obj[0] = args;
9069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9070 if (!SWIG_IsOK(res1)) {
9071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9072 }
9073 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 (arg1)->close();
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_Py_Void();
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 PyObject *swig_obj[1] ;
9093
9094 if (!args) SWIG_fail;
9095 swig_obj[0] = args;
9096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9097 if (!SWIG_IsOK(res1)) {
9098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9099 }
9100 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->flush();
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *resultobj = 0;
9116 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9117 bool result;
9118 void *argp1 = 0 ;
9119 int res1 = 0 ;
9120 PyObject *swig_obj[1] ;
9121
9122 if (!args) SWIG_fail;
9123 swig_obj[0] = args;
9124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9127 }
9128 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (bool)(arg1)->eof();
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 {
9136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9137 }
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj = 0;
9146 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9147 int arg2 = (int) -1 ;
9148 PyObject *result = 0 ;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 int val2 ;
9152 int ecode2 = 0 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 char * kwnames[] = {
9156 (char *) "self",(char *) "size", NULL
9157 };
9158
9159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9163 }
9164 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9165 if (obj1) {
9166 ecode2 = SWIG_AsVal_int(obj1, &val2);
9167 if (!SWIG_IsOK(ecode2)) {
9168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9169 }
9170 arg2 = static_cast< int >(val2);
9171 }
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 result = (PyObject *)(arg1)->read(arg2);
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 resultobj = result;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = 0;
9187 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9188 int arg2 = (int) -1 ;
9189 PyObject *result = 0 ;
9190 void *argp1 = 0 ;
9191 int res1 = 0 ;
9192 int val2 ;
9193 int ecode2 = 0 ;
9194 PyObject * obj0 = 0 ;
9195 PyObject * obj1 = 0 ;
9196 char * kwnames[] = {
9197 (char *) "self",(char *) "size", NULL
9198 };
9199
9200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9202 if (!SWIG_IsOK(res1)) {
9203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9204 }
9205 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9206 if (obj1) {
9207 ecode2 = SWIG_AsVal_int(obj1, &val2);
9208 if (!SWIG_IsOK(ecode2)) {
9209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9210 }
9211 arg2 = static_cast< int >(val2);
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (PyObject *)(arg1)->readline(arg2);
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = result;
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj = 0;
9228 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9229 int arg2 = (int) -1 ;
9230 PyObject *result = 0 ;
9231 void *argp1 = 0 ;
9232 int res1 = 0 ;
9233 int val2 ;
9234 int ecode2 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 char * kwnames[] = {
9238 (char *) "self",(char *) "sizehint", NULL
9239 };
9240
9241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 if (obj1) {
9248 ecode2 = SWIG_AsVal_int(obj1, &val2);
9249 if (!SWIG_IsOK(ecode2)) {
9250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9251 }
9252 arg2 = static_cast< int >(val2);
9253 }
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 result = (PyObject *)(arg1)->readlines(arg2);
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 resultobj = result;
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj = 0;
9269 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9270 int arg2 ;
9271 int arg3 = (int) 0 ;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 int val2 ;
9275 int ecode2 = 0 ;
9276 int val3 ;
9277 int ecode3 = 0 ;
9278 PyObject * obj0 = 0 ;
9279 PyObject * obj1 = 0 ;
9280 PyObject * obj2 = 0 ;
9281 char * kwnames[] = {
9282 (char *) "self",(char *) "offset",(char *) "whence", NULL
9283 };
9284
9285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9287 if (!SWIG_IsOK(res1)) {
9288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9289 }
9290 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9291 ecode2 = SWIG_AsVal_int(obj1, &val2);
9292 if (!SWIG_IsOK(ecode2)) {
9293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9294 }
9295 arg2 = static_cast< int >(val2);
9296 if (obj2) {
9297 ecode3 = SWIG_AsVal_int(obj2, &val3);
9298 if (!SWIG_IsOK(ecode3)) {
9299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9300 }
9301 arg3 = static_cast< int >(val3);
9302 }
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 (arg1)->seek(arg2,arg3);
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 resultobj = SWIG_Py_Void();
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317 PyObject *resultobj = 0;
9318 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9319 int result;
9320 void *argp1 = 0 ;
9321 int res1 = 0 ;
9322 PyObject *swig_obj[1] ;
9323
9324 if (!args) SWIG_fail;
9325 swig_obj[0] = args;
9326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9329 }
9330 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (int)(arg1)->tell();
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_From_int(static_cast< int >(result));
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9347 char result;
9348 void *argp1 = 0 ;
9349 int res1 = 0 ;
9350 PyObject *swig_obj[1] ;
9351
9352 if (!args) SWIG_fail;
9353 swig_obj[0] = args;
9354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9355 if (!SWIG_IsOK(res1)) {
9356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9357 }
9358 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (char)(arg1)->Peek();
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_From_char(static_cast< char >(result));
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9375 char result;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 PyObject *swig_obj[1] ;
9379
9380 if (!args) SWIG_fail;
9381 swig_obj[0] = args;
9382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9383 if (!SWIG_IsOK(res1)) {
9384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9385 }
9386 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9387 {
9388 PyThreadState* __tstate = wxPyBeginAllowThreads();
9389 result = (char)(arg1)->GetC();
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 resultobj = SWIG_From_char(static_cast< char >(result));
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9401 PyObject *resultobj = 0;
9402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9403 size_t result;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 PyObject *swig_obj[1] ;
9407
9408 if (!args) SWIG_fail;
9409 swig_obj[0] = args;
9410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (size_t)(arg1)->LastRead();
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9429 PyObject *resultobj = 0;
9430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9431 bool result;
9432 void *argp1 = 0 ;
9433 int res1 = 0 ;
9434 PyObject *swig_obj[1] ;
9435
9436 if (!args) SWIG_fail;
9437 swig_obj[0] = args;
9438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9439 if (!SWIG_IsOK(res1)) {
9440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9441 }
9442 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (bool)(arg1)->CanRead();
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 {
9450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9451 }
9452 return resultobj;
9453 fail:
9454 return NULL;
9455 }
9456
9457
9458 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9459 PyObject *resultobj = 0;
9460 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9461 bool result;
9462 void *argp1 = 0 ;
9463 int res1 = 0 ;
9464 PyObject *swig_obj[1] ;
9465
9466 if (!args) SWIG_fail;
9467 swig_obj[0] = args;
9468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9471 }
9472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (bool)(arg1)->Eof();
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9491 char arg2 ;
9492 bool result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 char val2 ;
9496 int ecode2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "c", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9507 }
9508 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9509 ecode2 = SWIG_AsVal_char(obj1, &val2);
9510 if (!SWIG_IsOK(ecode2)) {
9511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9512 }
9513 arg2 = static_cast< char >(val2);
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (bool)(arg1)->Ungetch(arg2);
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 {
9521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9522 }
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj = 0;
9531 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9532 long arg2 ;
9533 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9534 long result;
9535 void *argp1 = 0 ;
9536 int res1 = 0 ;
9537 long val2 ;
9538 int ecode2 = 0 ;
9539 int val3 ;
9540 int ecode3 = 0 ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 PyObject * obj2 = 0 ;
9544 char * kwnames[] = {
9545 (char *) "self",(char *) "pos",(char *) "mode", NULL
9546 };
9547
9548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9550 if (!SWIG_IsOK(res1)) {
9551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9552 }
9553 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9554 ecode2 = SWIG_AsVal_long(obj1, &val2);
9555 if (!SWIG_IsOK(ecode2)) {
9556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9557 }
9558 arg2 = static_cast< long >(val2);
9559 if (obj2) {
9560 ecode3 = SWIG_AsVal_int(obj2, &val3);
9561 if (!SWIG_IsOK(ecode3)) {
9562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9563 }
9564 arg3 = static_cast< wxSeekMode >(val3);
9565 }
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 result = (long)(arg1)->SeekI(arg2,arg3);
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 resultobj = SWIG_From_long(static_cast< long >(result));
9573 return resultobj;
9574 fail:
9575 return NULL;
9576 }
9577
9578
9579 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9580 PyObject *resultobj = 0;
9581 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9582 long result;
9583 void *argp1 = 0 ;
9584 int res1 = 0 ;
9585 PyObject *swig_obj[1] ;
9586
9587 if (!args) SWIG_fail;
9588 swig_obj[0] = args;
9589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9590 if (!SWIG_IsOK(res1)) {
9591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9592 }
9593 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 result = (long)(arg1)->TellI();
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_From_long(static_cast< long >(result));
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *obj;
9609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9610 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9611 return SWIG_Py_Void();
9612 }
9613
9614 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9615 return SWIG_Python_InitShadowInstance(args);
9616 }
9617
9618 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj = 0;
9620 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9621 PyObject *arg2 = (PyObject *) 0 ;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 PyObject * obj0 = 0 ;
9625 PyObject * obj1 = 0 ;
9626 char * kwnames[] = {
9627 (char *) "self",(char *) "obj", NULL
9628 };
9629
9630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9632 if (!SWIG_IsOK(res1)) {
9633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9634 }
9635 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9636 arg2 = obj1;
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 wxOutputStream_write(arg1,arg2);
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 resultobj = SWIG_Py_Void();
9644 return resultobj;
9645 fail:
9646 return NULL;
9647 }
9648
9649
9650 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9651 PyObject *resultobj = 0;
9652 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9653 size_t result;
9654 void *argp1 = 0 ;
9655 int res1 = 0 ;
9656 PyObject *swig_obj[1] ;
9657
9658 if (!args) SWIG_fail;
9659 swig_obj[0] = args;
9660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9661 if (!SWIG_IsOK(res1)) {
9662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9663 }
9664 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9672 return resultobj;
9673 fail:
9674 return NULL;
9675 }
9676
9677
9678 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9679 PyObject *obj;
9680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9681 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9682 return SWIG_Py_Void();
9683 }
9684
9685 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj = 0;
9687 wxInputStream *arg1 = (wxInputStream *) 0 ;
9688 wxString *arg2 = 0 ;
9689 wxString *arg3 = 0 ;
9690 wxString *arg4 = 0 ;
9691 wxDateTime arg5 ;
9692 wxFSFile *result = 0 ;
9693 wxPyInputStream *temp1 ;
9694 bool temp2 = false ;
9695 bool temp3 = false ;
9696 bool temp4 = false ;
9697 void *argp5 ;
9698 int res5 = 0 ;
9699 PyObject * obj0 = 0 ;
9700 PyObject * obj1 = 0 ;
9701 PyObject * obj2 = 0 ;
9702 PyObject * obj3 = 0 ;
9703 PyObject * obj4 = 0 ;
9704 char * kwnames[] = {
9705 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9706 };
9707
9708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9709 {
9710 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9711 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9712 } else {
9713 PyErr_Clear(); // clear the failure of the wxPyConvert above
9714 arg1 = wxPyCBInputStream_create(obj0, true);
9715 if (arg1 == NULL) {
9716 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9717 SWIG_fail;
9718 }
9719 }
9720 }
9721 {
9722 arg2 = wxString_in_helper(obj1);
9723 if (arg2 == NULL) SWIG_fail;
9724 temp2 = true;
9725 }
9726 {
9727 arg3 = wxString_in_helper(obj2);
9728 if (arg3 == NULL) SWIG_fail;
9729 temp3 = true;
9730 }
9731 {
9732 arg4 = wxString_in_helper(obj3);
9733 if (arg4 == NULL) SWIG_fail;
9734 temp4 = true;
9735 }
9736 {
9737 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9738 if (!SWIG_IsOK(res5)) {
9739 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9740 }
9741 if (!argp5) {
9742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9743 } else {
9744 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9745 arg5 = *temp;
9746 if (SWIG_IsNewObj(res5)) delete temp;
9747 }
9748 }
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9756 {
9757 if (temp2)
9758 delete arg2;
9759 }
9760 {
9761 if (temp3)
9762 delete arg3;
9763 }
9764 {
9765 if (temp4)
9766 delete arg4;
9767 }
9768 return resultobj;
9769 fail:
9770 {
9771 if (temp2)
9772 delete arg2;
9773 }
9774 {
9775 if (temp3)
9776 delete arg3;
9777 }
9778 {
9779 if (temp4)
9780 delete arg4;
9781 }
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9787 PyObject *resultobj = 0;
9788 wxFSFile *arg1 = (wxFSFile *) 0 ;
9789 void *argp1 = 0 ;
9790 int res1 = 0 ;
9791 PyObject *swig_obj[1] ;
9792
9793 if (!args) SWIG_fail;
9794 swig_obj[0] = args;
9795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 delete arg1;
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 resultobj = SWIG_Py_Void();
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9815 PyObject *resultobj = 0;
9816 wxFSFile *arg1 = (wxFSFile *) 0 ;
9817 wxInputStream *result = 0 ;
9818 void *argp1 = 0 ;
9819 int res1 = 0 ;
9820 PyObject *swig_obj[1] ;
9821
9822 if (!args) SWIG_fail;
9823 swig_obj[0] = args;
9824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9825 if (!SWIG_IsOK(res1)) {
9826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9827 }
9828 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxInputStream *)(arg1)->GetStream();
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 {
9836 wxPyInputStream * _ptr = NULL;
9837
9838 if (result) {
9839 _ptr = new wxPyInputStream(result);
9840 }
9841 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9842 }
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9850 PyObject *resultobj = 0;
9851 wxFSFile *arg1 = (wxFSFile *) 0 ;
9852 wxString *result = 0 ;
9853 void *argp1 = 0 ;
9854 int res1 = 0 ;
9855 PyObject *swig_obj[1] ;
9856
9857 if (!args) SWIG_fail;
9858 swig_obj[0] = args;
9859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9860 if (!SWIG_IsOK(res1)) {
9861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9862 }
9863 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 {
9867 wxString const &_result_ref = (arg1)->GetMimeType();
9868 result = (wxString *) &_result_ref;
9869 }
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 #if wxUSE_UNICODE
9875 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9876 #else
9877 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9878 #endif
9879 }
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *resultobj = 0;
9888 wxFSFile *arg1 = (wxFSFile *) 0 ;
9889 wxString *result = 0 ;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject *swig_obj[1] ;
9893
9894 if (!args) SWIG_fail;
9895 swig_obj[0] = args;
9896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9897 if (!SWIG_IsOK(res1)) {
9898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9899 }
9900 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 {
9904 wxString const &_result_ref = (arg1)->GetLocation();
9905 result = (wxString *) &_result_ref;
9906 }
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 {
9911 #if wxUSE_UNICODE
9912 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9913 #else
9914 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9915 #endif
9916 }
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9924 PyObject *resultobj = 0;
9925 wxFSFile *arg1 = (wxFSFile *) 0 ;
9926 wxString *result = 0 ;
9927 void *argp1 = 0 ;
9928 int res1 = 0 ;
9929 PyObject *swig_obj[1] ;
9930
9931 if (!args) SWIG_fail;
9932 swig_obj[0] = args;
9933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9934 if (!SWIG_IsOK(res1)) {
9935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9936 }
9937 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 {
9941 wxString const &_result_ref = (arg1)->GetAnchor();
9942 result = (wxString *) &_result_ref;
9943 }
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 {
9948 #if wxUSE_UNICODE
9949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9950 #else
9951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9952 #endif
9953 }
9954 return resultobj;
9955 fail:
9956 return NULL;
9957 }
9958
9959
9960 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9961 PyObject *resultobj = 0;
9962 wxFSFile *arg1 = (wxFSFile *) 0 ;
9963 wxDateTime result;
9964 void *argp1 = 0 ;
9965 int res1 = 0 ;
9966 PyObject *swig_obj[1] ;
9967
9968 if (!args) SWIG_fail;
9969 swig_obj[0] = args;
9970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9971 if (!SWIG_IsOK(res1)) {
9972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9973 }
9974 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (arg1)->GetModificationTime();
9978 wxPyEndAllowThreads(__tstate);
9979 if (PyErr_Occurred()) SWIG_fail;
9980 }
9981 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9989 PyObject *obj;
9990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9991 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9992 return SWIG_Py_Void();
9993 }
9994
9995 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9996 return SWIG_Python_InitShadowInstance(args);
9997 }
9998
9999 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10000 PyObject *resultobj = 0;
10001 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10002 void *argp1 = 0 ;
10003 int res1 = 0 ;
10004 PyObject *swig_obj[1] ;
10005
10006 if (!args) SWIG_fail;
10007 swig_obj[0] = args;
10008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10009 if (!SWIG_IsOK(res1)) {
10010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10011 }
10012 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 delete arg1;
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *obj;
10029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10030 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10031 return SWIG_Py_Void();
10032 }
10033
10034 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10035 PyObject *resultobj = 0;
10036 wxPyFileSystemHandler *result = 0 ;
10037
10038 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10039 {
10040 PyThreadState* __tstate = wxPyBeginAllowThreads();
10041 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10046 return resultobj;
10047 fail:
10048 return NULL;
10049 }
10050
10051
10052 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10053 PyObject *resultobj = 0;
10054 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10055 PyObject *arg2 = (PyObject *) 0 ;
10056 PyObject *arg3 = (PyObject *) 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 PyObject * obj2 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "self",(char *) "_class", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10070 }
10071 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10072 arg2 = obj1;
10073 arg3 = obj2;
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->_setCallbackInfo(arg2,arg3);
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10090 wxString *arg2 = 0 ;
10091 bool result;
10092 void *argp1 = 0 ;
10093 int res1 = 0 ;
10094 bool temp2 = false ;
10095 PyObject * obj0 = 0 ;
10096 PyObject * obj1 = 0 ;
10097 char * kwnames[] = {
10098 (char *) "self",(char *) "location", NULL
10099 };
10100
10101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10103 if (!SWIG_IsOK(res1)) {
10104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10105 }
10106 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10107 {
10108 arg2 = wxString_in_helper(obj1);
10109 if (arg2 == NULL) SWIG_fail;
10110 temp2 = true;
10111 }
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 {
10119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10120 }
10121 {
10122 if (temp2)
10123 delete arg2;
10124 }
10125 return resultobj;
10126 fail:
10127 {
10128 if (temp2)
10129 delete arg2;
10130 }
10131 return NULL;
10132 }
10133
10134
10135 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10136 PyObject *resultobj = 0;
10137 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10138 wxFileSystem *arg2 = 0 ;
10139 wxString *arg3 = 0 ;
10140 wxFSFile *result = 0 ;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 void *argp2 = 0 ;
10144 int res2 = 0 ;
10145 bool temp3 = false ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 PyObject * obj2 = 0 ;
10149 char * kwnames[] = {
10150 (char *) "self",(char *) "fs",(char *) "location", NULL
10151 };
10152
10153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10157 }
10158 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10160 if (!SWIG_IsOK(res2)) {
10161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10162 }
10163 if (!argp2) {
10164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10165 }
10166 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10167 {
10168 arg3 = wxString_in_helper(obj2);
10169 if (arg3 == NULL) SWIG_fail;
10170 temp3 = true;
10171 }
10172 {
10173 PyThreadState* __tstate = wxPyBeginAllowThreads();
10174 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 {
10179 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10180 }
10181 {
10182 if (temp3)
10183 delete arg3;
10184 }
10185 return resultobj;
10186 fail:
10187 {
10188 if (temp3)
10189 delete arg3;
10190 }
10191 return NULL;
10192 }
10193
10194
10195 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10196 PyObject *resultobj = 0;
10197 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10198 wxString *arg2 = 0 ;
10199 int arg3 = (int) 0 ;
10200 wxString result;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 bool temp2 = false ;
10204 int val3 ;
10205 int ecode3 = 0 ;
10206 PyObject * obj0 = 0 ;
10207 PyObject * obj1 = 0 ;
10208 PyObject * obj2 = 0 ;
10209 char * kwnames[] = {
10210 (char *) "self",(char *) "spec",(char *) "flags", NULL
10211 };
10212
10213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10215 if (!SWIG_IsOK(res1)) {
10216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10217 }
10218 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10219 {
10220 arg2 = wxString_in_helper(obj1);
10221 if (arg2 == NULL) SWIG_fail;
10222 temp2 = true;
10223 }
10224 if (obj2) {
10225 ecode3 = SWIG_AsVal_int(obj2, &val3);
10226 if (!SWIG_IsOK(ecode3)) {
10227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10228 }
10229 arg3 = static_cast< int >(val3);
10230 }
10231 {
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 {
10238 #if wxUSE_UNICODE
10239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10240 #else
10241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10242 #endif
10243 }
10244 {
10245 if (temp2)
10246 delete arg2;
10247 }
10248 return resultobj;
10249 fail:
10250 {
10251 if (temp2)
10252 delete arg2;
10253 }
10254 return NULL;
10255 }
10256
10257
10258 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10259 PyObject *resultobj = 0;
10260 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10261 wxString result;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 PyObject *swig_obj[1] ;
10265
10266 if (!args) SWIG_fail;
10267 swig_obj[0] = args;
10268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10271 }
10272 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 result = (arg1)->FindNext();
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 {
10280 #if wxUSE_UNICODE
10281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10282 #else
10283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10284 #endif
10285 }
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10293 PyObject *resultobj = 0;
10294 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10295 wxString *arg2 = 0 ;
10296 wxString result;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 bool temp2 = false ;
10300 PyObject * obj0 = 0 ;
10301 PyObject * obj1 = 0 ;
10302 char * kwnames[] = {
10303 (char *) "self",(char *) "location", NULL
10304 };
10305
10306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10308 if (!SWIG_IsOK(res1)) {
10309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10310 }
10311 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10312 {
10313 arg2 = wxString_in_helper(obj1);
10314 if (arg2 == NULL) SWIG_fail;
10315 temp2 = true;
10316 }
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (arg1)->GetProtocol((wxString const &)*arg2);
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 {
10324 #if wxUSE_UNICODE
10325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10326 #else
10327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10328 #endif
10329 }
10330 {
10331 if (temp2)
10332 delete arg2;
10333 }
10334 return resultobj;
10335 fail:
10336 {
10337 if (temp2)
10338 delete arg2;
10339 }
10340 return NULL;
10341 }
10342
10343
10344 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj = 0;
10346 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10347 wxString *arg2 = 0 ;
10348 wxString result;
10349 void *argp1 = 0 ;
10350 int res1 = 0 ;
10351 bool temp2 = false ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 char * kwnames[] = {
10355 (char *) "self",(char *) "location", NULL
10356 };
10357
10358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10360 if (!SWIG_IsOK(res1)) {
10361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10362 }
10363 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10364 {
10365 arg2 = wxString_in_helper(obj1);
10366 if (arg2 == NULL) SWIG_fail;
10367 temp2 = true;
10368 }
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 #if wxUSE_UNICODE
10377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10378 #else
10379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10380 #endif
10381 }
10382 {
10383 if (temp2)
10384 delete arg2;
10385 }
10386 return resultobj;
10387 fail:
10388 {
10389 if (temp2)
10390 delete arg2;
10391 }
10392 return NULL;
10393 }
10394
10395
10396 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10397 PyObject *resultobj = 0;
10398 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10399 wxString *arg2 = 0 ;
10400 wxString result;
10401 void *argp1 = 0 ;
10402 int res1 = 0 ;
10403 bool temp2 = false ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406 char * kwnames[] = {
10407 (char *) "self",(char *) "location", NULL
10408 };
10409
10410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10412 if (!SWIG_IsOK(res1)) {
10413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10414 }
10415 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10416 {
10417 arg2 = wxString_in_helper(obj1);
10418 if (arg2 == NULL) SWIG_fail;
10419 temp2 = true;
10420 }
10421 {
10422 PyThreadState* __tstate = wxPyBeginAllowThreads();
10423 result = (arg1)->GetAnchor((wxString const &)*arg2);
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 {
10428 #if wxUSE_UNICODE
10429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10430 #else
10431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10432 #endif
10433 }
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return resultobj;
10439 fail:
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return NULL;
10445 }
10446
10447
10448 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj = 0;
10450 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10451 wxString *arg2 = 0 ;
10452 wxString result;
10453 void *argp1 = 0 ;
10454 int res1 = 0 ;
10455 bool temp2 = false ;
10456 PyObject * obj0 = 0 ;
10457 PyObject * obj1 = 0 ;
10458 char * kwnames[] = {
10459 (char *) "self",(char *) "location", NULL
10460 };
10461
10462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10466 }
10467 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10468 {
10469 arg2 = wxString_in_helper(obj1);
10470 if (arg2 == NULL) SWIG_fail;
10471 temp2 = true;
10472 }
10473 {
10474 PyThreadState* __tstate = wxPyBeginAllowThreads();
10475 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10476 wxPyEndAllowThreads(__tstate);
10477 if (PyErr_Occurred()) SWIG_fail;
10478 }
10479 {
10480 #if wxUSE_UNICODE
10481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10482 #else
10483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10484 #endif
10485 }
10486 {
10487 if (temp2)
10488 delete arg2;
10489 }
10490 return resultobj;
10491 fail:
10492 {
10493 if (temp2)
10494 delete arg2;
10495 }
10496 return NULL;
10497 }
10498
10499
10500 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10501 PyObject *resultobj = 0;
10502 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10503 wxString *arg2 = 0 ;
10504 wxString result;
10505 void *argp1 = 0 ;
10506 int res1 = 0 ;
10507 bool temp2 = false ;
10508 PyObject * obj0 = 0 ;
10509 PyObject * obj1 = 0 ;
10510 char * kwnames[] = {
10511 (char *) "self",(char *) "location", NULL
10512 };
10513
10514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10516 if (!SWIG_IsOK(res1)) {
10517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10518 }
10519 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10520 {
10521 arg2 = wxString_in_helper(obj1);
10522 if (arg2 == NULL) SWIG_fail;
10523 temp2 = true;
10524 }
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 #if wxUSE_UNICODE
10533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10534 #else
10535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10536 #endif
10537 }
10538 {
10539 if (temp2)
10540 delete arg2;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp2)
10546 delete arg2;
10547 }
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *obj;
10554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10555 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10556 return SWIG_Py_Void();
10557 }
10558
10559 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10560 return SWIG_Python_InitShadowInstance(args);
10561 }
10562
10563 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10564 PyObject *resultobj = 0;
10565 wxFileSystem *result = 0 ;
10566
10567 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (wxFileSystem *)new wxFileSystem();
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10576 }
10577 return resultobj;
10578 fail:
10579 return NULL;
10580 }
10581
10582
10583 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10584 PyObject *resultobj = 0;
10585 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10586 void *argp1 = 0 ;
10587 int res1 = 0 ;
10588 PyObject *swig_obj[1] ;
10589
10590 if (!args) SWIG_fail;
10591 swig_obj[0] = args;
10592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10593 if (!SWIG_IsOK(res1)) {
10594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10595 }
10596 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10597 {
10598 PyThreadState* __tstate = wxPyBeginAllowThreads();
10599 delete arg1;
10600
10601 wxPyEndAllowThreads(__tstate);
10602 if (PyErr_Occurred()) SWIG_fail;
10603 }
10604 resultobj = SWIG_Py_Void();
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10612 PyObject *resultobj = 0;
10613 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10614 wxString *arg2 = 0 ;
10615 bool arg3 = (bool) false ;
10616 void *argp1 = 0 ;
10617 int res1 = 0 ;
10618 bool temp2 = false ;
10619 bool val3 ;
10620 int ecode3 = 0 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 PyObject * obj2 = 0 ;
10624 char * kwnames[] = {
10625 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10626 };
10627
10628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10630 if (!SWIG_IsOK(res1)) {
10631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10632 }
10633 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10634 {
10635 arg2 = wxString_in_helper(obj1);
10636 if (arg2 == NULL) SWIG_fail;
10637 temp2 = true;
10638 }
10639 if (obj2) {
10640 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10641 if (!SWIG_IsOK(ecode3)) {
10642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10643 }
10644 arg3 = static_cast< bool >(val3);
10645 }
10646 {
10647 PyThreadState* __tstate = wxPyBeginAllowThreads();
10648 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10649 wxPyEndAllowThreads(__tstate);
10650 if (PyErr_Occurred()) SWIG_fail;
10651 }
10652 resultobj = SWIG_Py_Void();
10653 {
10654 if (temp2)
10655 delete arg2;
10656 }
10657 return resultobj;
10658 fail:
10659 {
10660 if (temp2)
10661 delete arg2;
10662 }
10663 return NULL;
10664 }
10665
10666
10667 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10668 PyObject *resultobj = 0;
10669 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10670 wxString result;
10671 void *argp1 = 0 ;
10672 int res1 = 0 ;
10673 PyObject *swig_obj[1] ;
10674
10675 if (!args) SWIG_fail;
10676 swig_obj[0] = args;
10677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10678 if (!SWIG_IsOK(res1)) {
10679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10680 }
10681 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10682 {
10683 PyThreadState* __tstate = wxPyBeginAllowThreads();
10684 result = (arg1)->GetPath();
10685 wxPyEndAllowThreads(__tstate);
10686 if (PyErr_Occurred()) SWIG_fail;
10687 }
10688 {
10689 #if wxUSE_UNICODE
10690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10691 #else
10692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10693 #endif
10694 }
10695 return resultobj;
10696 fail:
10697 return NULL;
10698 }
10699
10700
10701 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10702 PyObject *resultobj = 0;
10703 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10704 wxString *arg2 = 0 ;
10705 wxFSFile *result = 0 ;
10706 void *argp1 = 0 ;
10707 int res1 = 0 ;
10708 bool temp2 = false ;
10709 PyObject * obj0 = 0 ;
10710 PyObject * obj1 = 0 ;
10711 char * kwnames[] = {
10712 (char *) "self",(char *) "location", NULL
10713 };
10714
10715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10719 }
10720 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10721 {
10722 arg2 = wxString_in_helper(obj1);
10723 if (arg2 == NULL) SWIG_fail;
10724 temp2 = true;
10725 }
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 {
10733 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10734 }
10735 {
10736 if (temp2)
10737 delete arg2;
10738 }
10739 return resultobj;
10740 fail:
10741 {
10742 if (temp2)
10743 delete arg2;
10744 }
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj = 0;
10751 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10752 wxString *arg2 = 0 ;
10753 int arg3 = (int) 0 ;
10754 wxString result;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 bool temp2 = false ;
10758 int val3 ;
10759 int ecode3 = 0 ;
10760 PyObject * obj0 = 0 ;
10761 PyObject * obj1 = 0 ;
10762 PyObject * obj2 = 0 ;
10763 char * kwnames[] = {
10764 (char *) "self",(char *) "spec",(char *) "flags", NULL
10765 };
10766
10767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10769 if (!SWIG_IsOK(res1)) {
10770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10771 }
10772 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10773 {
10774 arg2 = wxString_in_helper(obj1);
10775 if (arg2 == NULL) SWIG_fail;
10776 temp2 = true;
10777 }
10778 if (obj2) {
10779 ecode3 = SWIG_AsVal_int(obj2, &val3);
10780 if (!SWIG_IsOK(ecode3)) {
10781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10782 }
10783 arg3 = static_cast< int >(val3);
10784 }
10785 {
10786 PyThreadState* __tstate = wxPyBeginAllowThreads();
10787 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 {
10792 #if wxUSE_UNICODE
10793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10794 #else
10795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10796 #endif
10797 }
10798 {
10799 if (temp2)
10800 delete arg2;
10801 }
10802 return resultobj;
10803 fail:
10804 {
10805 if (temp2)
10806 delete arg2;
10807 }
10808 return NULL;
10809 }
10810
10811
10812 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10813 PyObject *resultobj = 0;
10814 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10815 wxString result;
10816 void *argp1 = 0 ;
10817 int res1 = 0 ;
10818 PyObject *swig_obj[1] ;
10819
10820 if (!args) SWIG_fail;
10821 swig_obj[0] = args;
10822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10823 if (!SWIG_IsOK(res1)) {
10824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10825 }
10826 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10827 {
10828 PyThreadState* __tstate = wxPyBeginAllowThreads();
10829 result = (arg1)->FindNext();
10830 wxPyEndAllowThreads(__tstate);
10831 if (PyErr_Occurred()) SWIG_fail;
10832 }
10833 {
10834 #if wxUSE_UNICODE
10835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10836 #else
10837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10838 #endif
10839 }
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj = 0;
10848 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10849 int res1 = 0 ;
10850 PyObject * obj0 = 0 ;
10851 char * kwnames[] = {
10852 (char *) "handler", NULL
10853 };
10854
10855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10856 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10857 if (!SWIG_IsOK(res1)) {
10858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 wxFileSystem::AddHandler(arg1);
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 resultobj = SWIG_Py_Void();
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10874 PyObject *resultobj = 0;
10875
10876 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10877 {
10878 PyThreadState* __tstate = wxPyBeginAllowThreads();
10879 wxFileSystem::CleanUpHandlers();
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxString *arg1 = 0 ;
10893 wxString result;
10894 bool temp1 = false ;
10895 PyObject * obj0 = 0 ;
10896 char * kwnames[] = {
10897 (char *) "filename", NULL
10898 };
10899
10900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10901 {
10902 arg1 = wxString_in_helper(obj0);
10903 if (arg1 == NULL) SWIG_fail;
10904 temp1 = true;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 #if wxUSE_UNICODE
10914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10915 #else
10916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10917 #endif
10918 }
10919 {
10920 if (temp1)
10921 delete arg1;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp1)
10927 delete arg1;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj = 0;
10935 wxString *arg1 = 0 ;
10936 wxString result;
10937 bool temp1 = false ;
10938 PyObject * obj0 = 0 ;
10939 char * kwnames[] = {
10940 (char *) "url", NULL
10941 };
10942
10943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10944 {
10945 arg1 = wxString_in_helper(obj0);
10946 if (arg1 == NULL) SWIG_fail;
10947 temp1 = true;
10948 }
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 {
10956 #if wxUSE_UNICODE
10957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10958 #else
10959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10960 #endif
10961 }
10962 {
10963 if (temp1)
10964 delete arg1;
10965 }
10966 return resultobj;
10967 fail:
10968 {
10969 if (temp1)
10970 delete arg1;
10971 }
10972 return NULL;
10973 }
10974
10975
10976 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10977 PyObject *obj;
10978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10979 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10980 return SWIG_Py_Void();
10981 }
10982
10983 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10984 return SWIG_Python_InitShadowInstance(args);
10985 }
10986
10987 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10988 PyObject *resultobj = 0;
10989 wxInternetFSHandler *result = 0 ;
10990
10991 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10992 {
10993 PyThreadState* __tstate = wxPyBeginAllowThreads();
10994 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10999 return resultobj;
11000 fail:
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11006 PyObject *resultobj = 0;
11007 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11008 wxString *arg2 = 0 ;
11009 bool result;
11010 void *argp1 = 0 ;
11011 int res1 = 0 ;
11012 bool temp2 = false ;
11013 PyObject * obj0 = 0 ;
11014 PyObject * obj1 = 0 ;
11015 char * kwnames[] = {
11016 (char *) "self",(char *) "location", NULL
11017 };
11018
11019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11021 if (!SWIG_IsOK(res1)) {
11022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11023 }
11024 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11025 {
11026 arg2 = wxString_in_helper(obj1);
11027 if (arg2 == NULL) SWIG_fail;
11028 temp2 = true;
11029 }
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 {
11037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11038 }
11039 {
11040 if (temp2)
11041 delete arg2;
11042 }
11043 return resultobj;
11044 fail:
11045 {
11046 if (temp2)
11047 delete arg2;
11048 }
11049 return NULL;
11050 }
11051
11052
11053 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11054 PyObject *resultobj = 0;
11055 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11056 wxFileSystem *arg2 = 0 ;
11057 wxString *arg3 = 0 ;
11058 wxFSFile *result = 0 ;
11059 void *argp1 = 0 ;
11060 int res1 = 0 ;
11061 void *argp2 = 0 ;
11062 int res2 = 0 ;
11063 bool temp3 = false ;
11064 PyObject * obj0 = 0 ;
11065 PyObject * obj1 = 0 ;
11066 PyObject * obj2 = 0 ;
11067 char * kwnames[] = {
11068 (char *) "self",(char *) "fs",(char *) "location", NULL
11069 };
11070
11071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11073 if (!SWIG_IsOK(res1)) {
11074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11075 }
11076 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11078 if (!SWIG_IsOK(res2)) {
11079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11080 }
11081 if (!argp2) {
11082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11083 }
11084 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11085 {
11086 arg3 = wxString_in_helper(obj2);
11087 if (arg3 == NULL) SWIG_fail;
11088 temp3 = true;
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11093 wxPyEndAllowThreads(__tstate);
11094 if (PyErr_Occurred()) SWIG_fail;
11095 }
11096 {
11097 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11098 }
11099 {
11100 if (temp3)
11101 delete arg3;
11102 }
11103 return resultobj;
11104 fail:
11105 {
11106 if (temp3)
11107 delete arg3;
11108 }
11109 return NULL;
11110 }
11111
11112
11113 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11114 PyObject *obj;
11115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11116 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11117 return SWIG_Py_Void();
11118 }
11119
11120 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11121 return SWIG_Python_InitShadowInstance(args);
11122 }
11123
11124 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125 PyObject *resultobj = 0;
11126 wxZipFSHandler *result = 0 ;
11127
11128 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11129 {
11130 PyThreadState* __tstate = wxPyBeginAllowThreads();
11131 result = (wxZipFSHandler *)new wxZipFSHandler();
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11136 return resultobj;
11137 fail:
11138 return NULL;
11139 }
11140
11141
11142 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11143 PyObject *resultobj = 0;
11144 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11145 wxString *arg2 = 0 ;
11146 bool result;
11147 void *argp1 = 0 ;
11148 int res1 = 0 ;
11149 bool temp2 = false ;
11150 PyObject * obj0 = 0 ;
11151 PyObject * obj1 = 0 ;
11152 char * kwnames[] = {
11153 (char *) "self",(char *) "location", NULL
11154 };
11155
11156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11158 if (!SWIG_IsOK(res1)) {
11159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11160 }
11161 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11162 {
11163 arg2 = wxString_in_helper(obj1);
11164 if (arg2 == NULL) SWIG_fail;
11165 temp2 = true;
11166 }
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 {
11174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11175 }
11176 {
11177 if (temp2)
11178 delete arg2;
11179 }
11180 return resultobj;
11181 fail:
11182 {
11183 if (temp2)
11184 delete arg2;
11185 }
11186 return NULL;
11187 }
11188
11189
11190 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj = 0;
11192 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11193 wxFileSystem *arg2 = 0 ;
11194 wxString *arg3 = 0 ;
11195 wxFSFile *result = 0 ;
11196 void *argp1 = 0 ;
11197 int res1 = 0 ;
11198 void *argp2 = 0 ;
11199 int res2 = 0 ;
11200 bool temp3 = false ;
11201 PyObject * obj0 = 0 ;
11202 PyObject * obj1 = 0 ;
11203 PyObject * obj2 = 0 ;
11204 char * kwnames[] = {
11205 (char *) "self",(char *) "fs",(char *) "location", NULL
11206 };
11207
11208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11210 if (!SWIG_IsOK(res1)) {
11211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11212 }
11213 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11215 if (!SWIG_IsOK(res2)) {
11216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11217 }
11218 if (!argp2) {
11219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11220 }
11221 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11222 {
11223 arg3 = wxString_in_helper(obj2);
11224 if (arg3 == NULL) SWIG_fail;
11225 temp3 = true;
11226 }
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 {
11234 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11235 }
11236 {
11237 if (temp3)
11238 delete arg3;
11239 }
11240 return resultobj;
11241 fail:
11242 {
11243 if (temp3)
11244 delete arg3;
11245 }
11246 return NULL;
11247 }
11248
11249
11250 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11251 PyObject *resultobj = 0;
11252 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11253 wxString *arg2 = 0 ;
11254 int arg3 = (int) 0 ;
11255 wxString result;
11256 void *argp1 = 0 ;
11257 int res1 = 0 ;
11258 bool temp2 = false ;
11259 int val3 ;
11260 int ecode3 = 0 ;
11261 PyObject * obj0 = 0 ;
11262 PyObject * obj1 = 0 ;
11263 PyObject * obj2 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "self",(char *) "spec",(char *) "flags", NULL
11266 };
11267
11268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11270 if (!SWIG_IsOK(res1)) {
11271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11272 }
11273 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11274 {
11275 arg2 = wxString_in_helper(obj1);
11276 if (arg2 == NULL) SWIG_fail;
11277 temp2 = true;
11278 }
11279 if (obj2) {
11280 ecode3 = SWIG_AsVal_int(obj2, &val3);
11281 if (!SWIG_IsOK(ecode3)) {
11282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11283 }
11284 arg3 = static_cast< int >(val3);
11285 }
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 {
11293 #if wxUSE_UNICODE
11294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11295 #else
11296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11297 #endif
11298 }
11299 {
11300 if (temp2)
11301 delete arg2;
11302 }
11303 return resultobj;
11304 fail:
11305 {
11306 if (temp2)
11307 delete arg2;
11308 }
11309 return NULL;
11310 }
11311
11312
11313 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11314 PyObject *resultobj = 0;
11315 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11316 wxString result;
11317 void *argp1 = 0 ;
11318 int res1 = 0 ;
11319 PyObject *swig_obj[1] ;
11320
11321 if (!args) SWIG_fail;
11322 swig_obj[0] = args;
11323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11324 if (!SWIG_IsOK(res1)) {
11325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11326 }
11327 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (arg1)->FindNext();
11331 wxPyEndAllowThreads(__tstate);
11332 if (PyErr_Occurred()) SWIG_fail;
11333 }
11334 {
11335 #if wxUSE_UNICODE
11336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11337 #else
11338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11339 #endif
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 PyObject *obj;
11349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11350 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11351 return SWIG_Py_Void();
11352 }
11353
11354 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11355 return SWIG_Python_InitShadowInstance(args);
11356 }
11357
11358 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj = 0;
11360 wxString *arg1 = 0 ;
11361 wxImage *arg2 = 0 ;
11362 long arg3 ;
11363 bool temp1 = false ;
11364 void *argp2 = 0 ;
11365 int res2 = 0 ;
11366 long val3 ;
11367 int ecode3 = 0 ;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "filename",(char *) "image",(char *) "type", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11376 {
11377 arg1 = wxString_in_helper(obj0);
11378 if (arg1 == NULL) SWIG_fail;
11379 temp1 = true;
11380 }
11381 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11382 if (!SWIG_IsOK(res2)) {
11383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11384 }
11385 if (!argp2) {
11386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11387 }
11388 arg2 = reinterpret_cast< wxImage * >(argp2);
11389 ecode3 = SWIG_AsVal_long(obj2, &val3);
11390 if (!SWIG_IsOK(ecode3)) {
11391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11392 }
11393 arg3 = static_cast< long >(val3);
11394 {
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 resultobj = SWIG_Py_Void();
11401 {
11402 if (temp1)
11403 delete arg1;
11404 }
11405 return resultobj;
11406 fail:
11407 {
11408 if (temp1)
11409 delete arg1;
11410 }
11411 return NULL;
11412 }
11413
11414
11415 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj = 0;
11417 wxString *arg1 = 0 ;
11418 wxBitmap *arg2 = 0 ;
11419 long arg3 ;
11420 bool temp1 = false ;
11421 void *argp2 = 0 ;
11422 int res2 = 0 ;
11423 long val3 ;
11424 int ecode3 = 0 ;
11425 PyObject * obj0 = 0 ;
11426 PyObject * obj1 = 0 ;
11427 PyObject * obj2 = 0 ;
11428 char * kwnames[] = {
11429 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11430 };
11431
11432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11433 {
11434 arg1 = wxString_in_helper(obj0);
11435 if (arg1 == NULL) SWIG_fail;
11436 temp1 = true;
11437 }
11438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11439 if (!SWIG_IsOK(res2)) {
11440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11441 }
11442 if (!argp2) {
11443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11444 }
11445 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11446 ecode3 = SWIG_AsVal_long(obj2, &val3);
11447 if (!SWIG_IsOK(ecode3)) {
11448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11449 }
11450 arg3 = static_cast< long >(val3);
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_Py_Void();
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return resultobj;
11463 fail:
11464 {
11465 if (temp1)
11466 delete arg1;
11467 }
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj = 0;
11474 wxString *arg1 = 0 ;
11475 PyObject *arg2 = (PyObject *) 0 ;
11476 bool temp1 = false ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 char * kwnames[] = {
11480 (char *) "filename",(char *) "data", NULL
11481 };
11482
11483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11484 {
11485 arg1 = wxString_in_helper(obj0);
11486 if (arg1 == NULL) SWIG_fail;
11487 temp1 = true;
11488 }
11489 arg2 = obj1;
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 resultobj = SWIG_Py_Void();
11497 {
11498 if (temp1)
11499 delete arg1;
11500 }
11501 return resultobj;
11502 fail:
11503 {
11504 if (temp1)
11505 delete arg1;
11506 }
11507 return NULL;
11508 }
11509
11510
11511 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11512 PyObject *resultobj = 0;
11513 wxMemoryFSHandler *result = 0 ;
11514
11515 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxString *arg1 = 0 ;
11532 bool temp1 = false ;
11533 PyObject * obj0 = 0 ;
11534 char * kwnames[] = {
11535 (char *) "filename", NULL
11536 };
11537
11538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11539 {
11540 arg1 = wxString_in_helper(obj0);
11541 if (arg1 == NULL) SWIG_fail;
11542 temp1 = true;
11543 }
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 resultobj = SWIG_Py_Void();
11551 {
11552 if (temp1)
11553 delete arg1;
11554 }
11555 return resultobj;
11556 fail:
11557 {
11558 if (temp1)
11559 delete arg1;
11560 }
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11568 wxString *arg2 = 0 ;
11569 bool result;
11570 void *argp1 = 0 ;
11571 int res1 = 0 ;
11572 bool temp2 = false ;
11573 PyObject * obj0 = 0 ;
11574 PyObject * obj1 = 0 ;
11575 char * kwnames[] = {
11576 (char *) "self",(char *) "location", NULL
11577 };
11578
11579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11581 if (!SWIG_IsOK(res1)) {
11582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11583 }
11584 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11585 {
11586 arg2 = wxString_in_helper(obj1);
11587 if (arg2 == NULL) SWIG_fail;
11588 temp2 = true;
11589 }
11590 {
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 {
11597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11598 }
11599 {
11600 if (temp2)
11601 delete arg2;
11602 }
11603 return resultobj;
11604 fail:
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 return NULL;
11610 }
11611
11612
11613 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj = 0;
11615 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11616 wxFileSystem *arg2 = 0 ;
11617 wxString *arg3 = 0 ;
11618 wxFSFile *result = 0 ;
11619 void *argp1 = 0 ;
11620 int res1 = 0 ;
11621 void *argp2 = 0 ;
11622 int res2 = 0 ;
11623 bool temp3 = false ;
11624 PyObject * obj0 = 0 ;
11625 PyObject * obj1 = 0 ;
11626 PyObject * obj2 = 0 ;
11627 char * kwnames[] = {
11628 (char *) "self",(char *) "fs",(char *) "location", NULL
11629 };
11630
11631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11635 }
11636 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11637 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11638 if (!SWIG_IsOK(res2)) {
11639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11640 }
11641 if (!argp2) {
11642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11643 }
11644 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11645 {
11646 arg3 = wxString_in_helper(obj2);
11647 if (arg3 == NULL) SWIG_fail;
11648 temp3 = true;
11649 }
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11658 }
11659 {
11660 if (temp3)
11661 delete arg3;
11662 }
11663 return resultobj;
11664 fail:
11665 {
11666 if (temp3)
11667 delete arg3;
11668 }
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11676 wxString *arg2 = 0 ;
11677 int arg3 = (int) 0 ;
11678 wxString result;
11679 void *argp1 = 0 ;
11680 int res1 = 0 ;
11681 bool temp2 = false ;
11682 int val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "spec",(char *) "flags", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11695 }
11696 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11697 {
11698 arg2 = wxString_in_helper(obj1);
11699 if (arg2 == NULL) SWIG_fail;
11700 temp2 = true;
11701 }
11702 if (obj2) {
11703 ecode3 = SWIG_AsVal_int(obj2, &val3);
11704 if (!SWIG_IsOK(ecode3)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11706 }
11707 arg3 = static_cast< int >(val3);
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 #if wxUSE_UNICODE
11717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11718 #else
11719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11720 #endif
11721 }
11722 {
11723 if (temp2)
11724 delete arg2;
11725 }
11726 return resultobj;
11727 fail:
11728 {
11729 if (temp2)
11730 delete arg2;
11731 }
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *resultobj = 0;
11738 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11739 wxString result;
11740 void *argp1 = 0 ;
11741 int res1 = 0 ;
11742 PyObject *swig_obj[1] ;
11743
11744 if (!args) SWIG_fail;
11745 swig_obj[0] = args;
11746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11747 if (!SWIG_IsOK(res1)) {
11748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11749 }
11750 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11751 {
11752 PyThreadState* __tstate = wxPyBeginAllowThreads();
11753 result = (arg1)->FindNext();
11754 wxPyEndAllowThreads(__tstate);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 {
11758 #if wxUSE_UNICODE
11759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11760 #else
11761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11762 #endif
11763 }
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 PyObject *obj;
11772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11773 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11774 return SWIG_Py_Void();
11775 }
11776
11777 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11778 return SWIG_Python_InitShadowInstance(args);
11779 }
11780
11781 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11782 PyObject *resultobj = 0;
11783 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11784 wxString result;
11785 void *argp1 = 0 ;
11786 int res1 = 0 ;
11787 PyObject *swig_obj[1] ;
11788
11789 if (!args) SWIG_fail;
11790 swig_obj[0] = args;
11791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11792 if (!SWIG_IsOK(res1)) {
11793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11794 }
11795 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (arg1)->GetName();
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 {
11803 #if wxUSE_UNICODE
11804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11805 #else
11806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11807 #endif
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11816 PyObject *resultobj = 0;
11817 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11818 wxString result;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 PyObject *swig_obj[1] ;
11822
11823 if (!args) SWIG_fail;
11824 swig_obj[0] = args;
11825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11826 if (!SWIG_IsOK(res1)) {
11827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11828 }
11829 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (arg1)->GetExtension();
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 #if wxUSE_UNICODE
11838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11839 #else
11840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11841 #endif
11842 }
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11852 long result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11862 }
11863 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (long)(arg1)->GetType();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 resultobj = SWIG_From_long(static_cast< long >(result));
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *resultobj = 0;
11879 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11880 wxString result;
11881 void *argp1 = 0 ;
11882 int res1 = 0 ;
11883 PyObject *swig_obj[1] ;
11884
11885 if (!args) SWIG_fail;
11886 swig_obj[0] = args;
11887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11888 if (!SWIG_IsOK(res1)) {
11889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11890 }
11891 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 result = (arg1)->GetMimeType();
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 {
11899 #if wxUSE_UNICODE
11900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11901 #else
11902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11903 #endif
11904 }
11905 return resultobj;
11906 fail:
11907 return NULL;
11908 }
11909
11910
11911 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11912 PyObject *resultobj = 0;
11913 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11914 wxString *arg2 = 0 ;
11915 bool result;
11916 void *argp1 = 0 ;
11917 int res1 = 0 ;
11918 bool temp2 = false ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 char * kwnames[] = {
11922 (char *) "self",(char *) "name", NULL
11923 };
11924
11925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11929 }
11930 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11931 {
11932 arg2 = wxString_in_helper(obj1);
11933 if (arg2 == NULL) SWIG_fail;
11934 temp2 = true;
11935 }
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 {
11946 if (temp2)
11947 delete arg2;
11948 }
11949 return resultobj;
11950 fail:
11951 {
11952 if (temp2)
11953 delete arg2;
11954 }
11955 return NULL;
11956 }
11957
11958
11959 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj = 0;
11961 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11962 wxInputStream *arg2 = 0 ;
11963 bool result;
11964 void *argp1 = 0 ;
11965 int res1 = 0 ;
11966 wxPyInputStream *temp2 ;
11967 bool created2 ;
11968 PyObject * obj0 = 0 ;
11969 PyObject * obj1 = 0 ;
11970 char * kwnames[] = {
11971 (char *) "self",(char *) "stream", NULL
11972 };
11973
11974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11976 if (!SWIG_IsOK(res1)) {
11977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11978 }
11979 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11980 {
11981 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11982 arg2 = temp2->m_wxis;
11983 created2 = false;
11984 } else {
11985 PyErr_Clear(); // clear the failure of the wxPyConvert above
11986 arg2 = wxPyCBInputStream_create(obj1, false);
11987 if (arg2 == NULL) {
11988 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11989 SWIG_fail;
11990 }
11991 created2 = true;
11992 }
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (bool)(arg1)->CanRead(*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12002 }
12003 {
12004 if (created2) delete arg2;
12005 }
12006 return resultobj;
12007 fail:
12008 {
12009 if (created2) delete arg2;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj = 0;
12017 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12018 wxString *arg2 = 0 ;
12019 void *argp1 = 0 ;
12020 int res1 = 0 ;
12021 bool temp2 = false ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 char * kwnames[] = {
12025 (char *) "self",(char *) "name", NULL
12026 };
12027
12028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12032 }
12033 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12034 {
12035 arg2 = wxString_in_helper(obj1);
12036 if (arg2 == NULL) SWIG_fail;
12037 temp2 = true;
12038 }
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 (arg1)->SetName((wxString const &)*arg2);
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_Py_Void();
12046 {
12047 if (temp2)
12048 delete arg2;
12049 }
12050 return resultobj;
12051 fail:
12052 {
12053 if (temp2)
12054 delete arg2;
12055 }
12056 return NULL;
12057 }
12058
12059
12060 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12061 PyObject *resultobj = 0;
12062 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12063 wxString *arg2 = 0 ;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 bool temp2 = false ;
12067 PyObject * obj0 = 0 ;
12068 PyObject * obj1 = 0 ;
12069 char * kwnames[] = {
12070 (char *) "self",(char *) "extension", NULL
12071 };
12072
12073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12075 if (!SWIG_IsOK(res1)) {
12076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12077 }
12078 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12079 {
12080 arg2 = wxString_in_helper(obj1);
12081 if (arg2 == NULL) SWIG_fail;
12082 temp2 = true;
12083 }
12084 {
12085 PyThreadState* __tstate = wxPyBeginAllowThreads();
12086 (arg1)->SetExtension((wxString const &)*arg2);
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 resultobj = SWIG_Py_Void();
12091 {
12092 if (temp2)
12093 delete arg2;
12094 }
12095 return resultobj;
12096 fail:
12097 {
12098 if (temp2)
12099 delete arg2;
12100 }
12101 return NULL;
12102 }
12103
12104
12105 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj = 0;
12107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12108 long arg2 ;
12109 void *argp1 = 0 ;
12110 int res1 = 0 ;
12111 long val2 ;
12112 int ecode2 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 char * kwnames[] = {
12116 (char *) "self",(char *) "type", NULL
12117 };
12118
12119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12121 if (!SWIG_IsOK(res1)) {
12122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12123 }
12124 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12125 ecode2 = SWIG_AsVal_long(obj1, &val2);
12126 if (!SWIG_IsOK(ecode2)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12128 }
12129 arg2 = static_cast< long >(val2);
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 (arg1)->SetType(arg2);
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_Py_Void();
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12144 PyObject *resultobj = 0;
12145 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12146 wxString *arg2 = 0 ;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 bool temp2 = false ;
12150 PyObject * obj0 = 0 ;
12151 PyObject * obj1 = 0 ;
12152 char * kwnames[] = {
12153 (char *) "self",(char *) "mimetype", NULL
12154 };
12155
12156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12158 if (!SWIG_IsOK(res1)) {
12159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12160 }
12161 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12162 {
12163 arg2 = wxString_in_helper(obj1);
12164 if (arg2 == NULL) SWIG_fail;
12165 temp2 = true;
12166 }
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 (arg1)->SetMimeType((wxString const &)*arg2);
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_Py_Void();
12174 {
12175 if (temp2)
12176 delete arg2;
12177 }
12178 return resultobj;
12179 fail:
12180 {
12181 if (temp2)
12182 delete arg2;
12183 }
12184 return NULL;
12185 }
12186
12187
12188 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12189 PyObject *obj;
12190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12191 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12192 return SWIG_Py_Void();
12193 }
12194
12195 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12196 PyObject *resultobj = 0;
12197 wxPyImageHandler *result = 0 ;
12198
12199 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 result = (wxPyImageHandler *)new wxPyImageHandler();
12203 wxPyEndAllowThreads(__tstate);
12204 if (PyErr_Occurred()) SWIG_fail;
12205 }
12206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12207 return resultobj;
12208 fail:
12209 return NULL;
12210 }
12211
12212
12213 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12214 PyObject *resultobj = 0;
12215 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12216 PyObject *arg2 = (PyObject *) 0 ;
12217 void *argp1 = 0 ;
12218 int res1 = 0 ;
12219 PyObject * obj0 = 0 ;
12220 PyObject * obj1 = 0 ;
12221 char * kwnames[] = {
12222 (char *) "self",(char *) "self", NULL
12223 };
12224
12225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12227 if (!SWIG_IsOK(res1)) {
12228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12229 }
12230 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12231 arg2 = obj1;
12232 {
12233 PyThreadState* __tstate = wxPyBeginAllowThreads();
12234 (arg1)->_SetSelf(arg2);
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 resultobj = SWIG_Py_Void();
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12246 PyObject *obj;
12247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12248 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12249 return SWIG_Py_Void();
12250 }
12251
12252 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12253 return SWIG_Python_InitShadowInstance(args);
12254 }
12255
12256 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12257 PyObject *resultobj = 0;
12258 wxImageHistogram *result = 0 ;
12259
12260 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 result = (wxImageHistogram *)new wxImageHistogram();
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj = 0;
12276 byte arg1 ;
12277 byte arg2 ;
12278 byte arg3 ;
12279 unsigned long result;
12280 unsigned char val1 ;
12281 int ecode1 = 0 ;
12282 unsigned char val2 ;
12283 int ecode2 = 0 ;
12284 unsigned char val3 ;
12285 int ecode3 = 0 ;
12286 PyObject * obj0 = 0 ;
12287 PyObject * obj1 = 0 ;
12288 PyObject * obj2 = 0 ;
12289 char * kwnames[] = {
12290 (char *) "r",(char *) "g",(char *) "b", NULL
12291 };
12292
12293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12294 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12295 if (!SWIG_IsOK(ecode1)) {
12296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12297 }
12298 arg1 = static_cast< byte >(val1);
12299 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12300 if (!SWIG_IsOK(ecode2)) {
12301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12302 }
12303 arg2 = static_cast< byte >(val2);
12304 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12305 if (!SWIG_IsOK(ecode3)) {
12306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12307 }
12308 arg3 = static_cast< byte >(val3);
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj = 0;
12324 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12325 byte *arg2 = (byte *) 0 ;
12326 byte *arg3 = (byte *) 0 ;
12327 byte *arg4 = (byte *) 0 ;
12328 byte arg5 = (byte) 1 ;
12329 byte arg6 = (byte) 0 ;
12330 byte arg7 = (byte) 0 ;
12331 bool result;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 byte temp2 ;
12335 int res2 = SWIG_TMPOBJ ;
12336 byte temp3 ;
12337 int res3 = SWIG_TMPOBJ ;
12338 byte temp4 ;
12339 int res4 = SWIG_TMPOBJ ;
12340 unsigned char val5 ;
12341 int ecode5 = 0 ;
12342 unsigned char val6 ;
12343 int ecode6 = 0 ;
12344 unsigned char val7 ;
12345 int ecode7 = 0 ;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 PyObject * obj2 = 0 ;
12349 PyObject * obj3 = 0 ;
12350 char * kwnames[] = {
12351 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12352 };
12353
12354 arg2 = &temp2;
12355 arg3 = &temp3;
12356 arg4 = &temp4;
12357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12359 if (!SWIG_IsOK(res1)) {
12360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12361 }
12362 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12363 if (obj1) {
12364 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12365 if (!SWIG_IsOK(ecode5)) {
12366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12367 }
12368 arg5 = static_cast< byte >(val5);
12369 }
12370 if (obj2) {
12371 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12372 if (!SWIG_IsOK(ecode6)) {
12373 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12374 }
12375 arg6 = static_cast< byte >(val6);
12376 }
12377 if (obj3) {
12378 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12379 if (!SWIG_IsOK(ecode7)) {
12380 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12381 }
12382 arg7 = static_cast< byte >(val7);
12383 }
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 {
12391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12392 }
12393 if (SWIG_IsTmpObj(res2)) {
12394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12395 } else {
12396 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12398 }
12399 if (SWIG_IsTmpObj(res3)) {
12400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12401 } else {
12402 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12404 }
12405 if (SWIG_IsTmpObj(res4)) {
12406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12407 } else {
12408 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12410 }
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12418 PyObject *resultobj = 0;
12419 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12420 unsigned long arg2 ;
12421 unsigned long result;
12422 void *argp1 = 0 ;
12423 int res1 = 0 ;
12424 unsigned long val2 ;
12425 int ecode2 = 0 ;
12426 PyObject * obj0 = 0 ;
12427 PyObject * obj1 = 0 ;
12428 char * kwnames[] = {
12429 (char *) "self",(char *) "key", NULL
12430 };
12431
12432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12434 if (!SWIG_IsOK(res1)) {
12435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12436 }
12437 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12438 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12439 if (!SWIG_IsOK(ecode2)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12441 }
12442 arg2 = static_cast< unsigned long >(val2);
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj = 0;
12458 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12459 byte arg2 ;
12460 byte arg3 ;
12461 byte arg4 ;
12462 unsigned long result;
12463 void *argp1 = 0 ;
12464 int res1 = 0 ;
12465 unsigned char val2 ;
12466 int ecode2 = 0 ;
12467 unsigned char val3 ;
12468 int ecode3 = 0 ;
12469 unsigned char val4 ;
12470 int ecode4 = 0 ;
12471 PyObject * obj0 = 0 ;
12472 PyObject * obj1 = 0 ;
12473 PyObject * obj2 = 0 ;
12474 PyObject * obj3 = 0 ;
12475 char * kwnames[] = {
12476 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12477 };
12478
12479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12481 if (!SWIG_IsOK(res1)) {
12482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12483 }
12484 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12485 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12486 if (!SWIG_IsOK(ecode2)) {
12487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12488 }
12489 arg2 = static_cast< byte >(val2);
12490 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12491 if (!SWIG_IsOK(ecode3)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12493 }
12494 arg3 = static_cast< byte >(val3);
12495 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12496 if (!SWIG_IsOK(ecode4)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12498 }
12499 arg4 = static_cast< byte >(val4);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12516 wxColour *arg2 = 0 ;
12517 unsigned long result;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 wxColour temp2 ;
12521 PyObject * obj0 = 0 ;
12522 PyObject * obj1 = 0 ;
12523 char * kwnames[] = {
12524 (char *) "self",(char *) "colour", NULL
12525 };
12526
12527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12531 }
12532 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12533 {
12534 arg2 = &temp2;
12535 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12536 }
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *obj;
12552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12553 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12554 return SWIG_Py_Void();
12555 }
12556
12557 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12558 return SWIG_Python_InitShadowInstance(args);
12559 }
12560
12561 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12562 PyObject *resultobj = 0;
12563 byte arg1 = (byte) 0 ;
12564 byte arg2 = (byte) 0 ;
12565 byte arg3 = (byte) 0 ;
12566 wxImage_RGBValue *result = 0 ;
12567 unsigned char val1 ;
12568 int ecode1 = 0 ;
12569 unsigned char val2 ;
12570 int ecode2 = 0 ;
12571 unsigned char val3 ;
12572 int ecode3 = 0 ;
12573 PyObject * obj0 = 0 ;
12574 PyObject * obj1 = 0 ;
12575 PyObject * obj2 = 0 ;
12576 char * kwnames[] = {
12577 (char *) "r",(char *) "g",(char *) "b", NULL
12578 };
12579
12580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12581 if (obj0) {
12582 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12583 if (!SWIG_IsOK(ecode1)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12585 }
12586 arg1 = static_cast< byte >(val1);
12587 }
12588 if (obj1) {
12589 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12592 }
12593 arg2 = static_cast< byte >(val2);
12594 }
12595 if (obj2) {
12596 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12597 if (!SWIG_IsOK(ecode3)) {
12598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12599 }
12600 arg3 = static_cast< byte >(val3);
12601 }
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_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_red_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_red_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_red_set" "', expected argument " "2"" of type '" "byte""'");
12634 }
12635 arg2 = static_cast< byte >(val2);
12636 if (arg1) (arg1)->red = arg2;
12637
12638 resultobj = SWIG_Py_Void();
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_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_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12660 result = (byte) ((arg1)->red);
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 *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12669 PyObject *resultobj = 0;
12670 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12671 byte arg2 ;
12672 void *argp1 = 0 ;
12673 int res1 = 0 ;
12674 unsigned char val2 ;
12675 int ecode2 = 0 ;
12676 PyObject *swig_obj[2] ;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12680 if (!SWIG_IsOK(res1)) {
12681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12682 }
12683 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12684 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12685 if (!SWIG_IsOK(ecode2)) {
12686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12687 }
12688 arg2 = static_cast< byte >(val2);
12689 if (arg1) (arg1)->green = arg2;
12690
12691 resultobj = SWIG_Py_Void();
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12699 PyObject *resultobj = 0;
12700 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12701 byte result;
12702 void *argp1 = 0 ;
12703 int res1 = 0 ;
12704 PyObject *swig_obj[1] ;
12705
12706 if (!args) SWIG_fail;
12707 swig_obj[0] = args;
12708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12711 }
12712 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12713 result = (byte) ((arg1)->green);
12714 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12722 PyObject *resultobj = 0;
12723 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12724 byte arg2 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 unsigned char val2 ;
12728 int ecode2 = 0 ;
12729 PyObject *swig_obj[2] ;
12730
12731 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12733 if (!SWIG_IsOK(res1)) {
12734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12735 }
12736 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12737 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12738 if (!SWIG_IsOK(ecode2)) {
12739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12740 }
12741 arg2 = static_cast< byte >(val2);
12742 if (arg1) (arg1)->blue = arg2;
12743
12744 resultobj = SWIG_Py_Void();
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12754 byte result;
12755 void *argp1 = 0 ;
12756 int res1 = 0 ;
12757 PyObject *swig_obj[1] ;
12758
12759 if (!args) SWIG_fail;
12760 swig_obj[0] = args;
12761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12764 }
12765 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12766 result = (byte) ((arg1)->blue);
12767 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12775 PyObject *obj;
12776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12777 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12778 return SWIG_Py_Void();
12779 }
12780
12781 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12782 return SWIG_Python_InitShadowInstance(args);
12783 }
12784
12785 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12786 PyObject *resultobj = 0;
12787 double arg1 = (double) 0.0 ;
12788 double arg2 = (double) 0.0 ;
12789 double arg3 = (double) 0.0 ;
12790 wxImage_HSVValue *result = 0 ;
12791 double val1 ;
12792 int ecode1 = 0 ;
12793 double val2 ;
12794 int ecode2 = 0 ;
12795 double val3 ;
12796 int ecode3 = 0 ;
12797 PyObject * obj0 = 0 ;
12798 PyObject * obj1 = 0 ;
12799 PyObject * obj2 = 0 ;
12800 char * kwnames[] = {
12801 (char *) "h",(char *) "s",(char *) "v", NULL
12802 };
12803
12804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12805 if (obj0) {
12806 ecode1 = SWIG_AsVal_double(obj0, &val1);
12807 if (!SWIG_IsOK(ecode1)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12809 }
12810 arg1 = static_cast< double >(val1);
12811 }
12812 if (obj1) {
12813 ecode2 = SWIG_AsVal_double(obj1, &val2);
12814 if (!SWIG_IsOK(ecode2)) {
12815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12816 }
12817 arg2 = static_cast< double >(val2);
12818 }
12819 if (obj2) {
12820 ecode3 = SWIG_AsVal_double(obj2, &val3);
12821 if (!SWIG_IsOK(ecode3)) {
12822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12823 }
12824 arg3 = static_cast< double >(val3);
12825 }
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_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_hue_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_hue_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_hue_set" "', expected argument " "2"" of type '" "double""'");
12858 }
12859 arg2 = static_cast< double >(val2);
12860 if (arg1) (arg1)->hue = arg2;
12861
12862 resultobj = SWIG_Py_Void();
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_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_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12882 }
12883 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12884 result = (double) ((arg1)->hue);
12885 resultobj = SWIG_From_double(static_cast< double >(result));
12886 return resultobj;
12887 fail:
12888 return NULL;
12889 }
12890
12891
12892 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *resultobj = 0;
12894 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12895 double arg2 ;
12896 void *argp1 = 0 ;
12897 int res1 = 0 ;
12898 double val2 ;
12899 int ecode2 = 0 ;
12900 PyObject *swig_obj[2] ;
12901
12902 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12904 if (!SWIG_IsOK(res1)) {
12905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12906 }
12907 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12908 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12909 if (!SWIG_IsOK(ecode2)) {
12910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12911 }
12912 arg2 = static_cast< double >(val2);
12913 if (arg1) (arg1)->saturation = arg2;
12914
12915 resultobj = SWIG_Py_Void();
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *resultobj = 0;
12924 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12925 double result;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 PyObject *swig_obj[1] ;
12929
12930 if (!args) SWIG_fail;
12931 swig_obj[0] = args;
12932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12933 if (!SWIG_IsOK(res1)) {
12934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12935 }
12936 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12937 result = (double) ((arg1)->saturation);
12938 resultobj = SWIG_From_double(static_cast< double >(result));
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12946 PyObject *resultobj = 0;
12947 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12948 double arg2 ;
12949 void *argp1 = 0 ;
12950 int res1 = 0 ;
12951 double val2 ;
12952 int ecode2 = 0 ;
12953 PyObject *swig_obj[2] ;
12954
12955 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12957 if (!SWIG_IsOK(res1)) {
12958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12959 }
12960 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12961 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12962 if (!SWIG_IsOK(ecode2)) {
12963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12964 }
12965 arg2 = static_cast< double >(val2);
12966 if (arg1) (arg1)->value = arg2;
12967
12968 resultobj = SWIG_Py_Void();
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *resultobj = 0;
12977 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12978 double result;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 PyObject *swig_obj[1] ;
12982
12983 if (!args) SWIG_fail;
12984 swig_obj[0] = args;
12985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12986 if (!SWIG_IsOK(res1)) {
12987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12988 }
12989 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12990 result = (double) ((arg1)->value);
12991 resultobj = SWIG_From_double(static_cast< double >(result));
12992 return resultobj;
12993 fail:
12994 return NULL;
12995 }
12996
12997
12998 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12999 PyObject *obj;
13000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13001 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13002 return SWIG_Py_Void();
13003 }
13004
13005 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 return SWIG_Python_InitShadowInstance(args);
13007 }
13008
13009 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj = 0;
13011 wxString *arg1 = 0 ;
13012 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13013 int arg3 = (int) -1 ;
13014 wxImage *result = 0 ;
13015 bool temp1 = false ;
13016 long val2 ;
13017 int ecode2 = 0 ;
13018 int val3 ;
13019 int ecode3 = 0 ;
13020 PyObject * obj0 = 0 ;
13021 PyObject * obj1 = 0 ;
13022 PyObject * obj2 = 0 ;
13023 char * kwnames[] = {
13024 (char *) "name",(char *) "type",(char *) "index", NULL
13025 };
13026
13027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13028 {
13029 arg1 = wxString_in_helper(obj0);
13030 if (arg1 == NULL) SWIG_fail;
13031 temp1 = true;
13032 }
13033 if (obj1) {
13034 ecode2 = SWIG_AsVal_long(obj1, &val2);
13035 if (!SWIG_IsOK(ecode2)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13037 }
13038 arg2 = static_cast< long >(val2);
13039 }
13040 if (obj2) {
13041 ecode3 = SWIG_AsVal_int(obj2, &val3);
13042 if (!SWIG_IsOK(ecode3)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13044 }
13045 arg3 = static_cast< int >(val3);
13046 }
13047 {
13048 PyThreadState* __tstate = wxPyBeginAllowThreads();
13049 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13054 {
13055 if (temp1)
13056 delete arg1;
13057 }
13058 return resultobj;
13059 fail:
13060 {
13061 if (temp1)
13062 delete arg1;
13063 }
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *resultobj = 0;
13070 wxImage *arg1 = (wxImage *) 0 ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 PyObject *swig_obj[1] ;
13074
13075 if (!args) SWIG_fail;
13076 swig_obj[0] = args;
13077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13078 if (!SWIG_IsOK(res1)) {
13079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13080 }
13081 arg1 = reinterpret_cast< wxImage * >(argp1);
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 delete arg1;
13085
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 resultobj = SWIG_Py_Void();
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13097 PyObject *resultobj = 0;
13098 wxString *arg1 = 0 ;
13099 wxString *arg2 = 0 ;
13100 int arg3 = (int) -1 ;
13101 wxImage *result = 0 ;
13102 bool temp1 = false ;
13103 bool temp2 = false ;
13104 int val3 ;
13105 int ecode3 = 0 ;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 PyObject * obj2 = 0 ;
13109 char * kwnames[] = {
13110 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13111 };
13112
13113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13114 {
13115 arg1 = wxString_in_helper(obj0);
13116 if (arg1 == NULL) SWIG_fail;
13117 temp1 = true;
13118 }
13119 {
13120 arg2 = wxString_in_helper(obj1);
13121 if (arg2 == NULL) SWIG_fail;
13122 temp2 = true;
13123 }
13124 if (obj2) {
13125 ecode3 = SWIG_AsVal_int(obj2, &val3);
13126 if (!SWIG_IsOK(ecode3)) {
13127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13128 }
13129 arg3 = static_cast< int >(val3);
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13134 wxPyEndAllowThreads(__tstate);
13135 if (PyErr_Occurred()) SWIG_fail;
13136 }
13137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13138 {
13139 if (temp1)
13140 delete arg1;
13141 }
13142 {
13143 if (temp2)
13144 delete arg2;
13145 }
13146 return resultobj;
13147 fail:
13148 {
13149 if (temp1)
13150 delete arg1;
13151 }
13152 {
13153 if (temp2)
13154 delete arg2;
13155 }
13156 return NULL;
13157 }
13158
13159
13160 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13161 PyObject *resultobj = 0;
13162 wxInputStream *arg1 = 0 ;
13163 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13164 int arg3 = (int) -1 ;
13165 wxImage *result = 0 ;
13166 wxPyInputStream *temp1 ;
13167 bool created1 ;
13168 long val2 ;
13169 int ecode2 = 0 ;
13170 int val3 ;
13171 int ecode3 = 0 ;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 PyObject * obj2 = 0 ;
13175 char * kwnames[] = {
13176 (char *) "stream",(char *) "type",(char *) "index", NULL
13177 };
13178
13179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13180 {
13181 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13182 arg1 = temp1->m_wxis;
13183 created1 = false;
13184 } else {
13185 PyErr_Clear(); // clear the failure of the wxPyConvert above
13186 arg1 = wxPyCBInputStream_create(obj0, false);
13187 if (arg1 == NULL) {
13188 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13189 SWIG_fail;
13190 }
13191 created1 = true;
13192 }
13193 }
13194 if (obj1) {
13195 ecode2 = SWIG_AsVal_long(obj1, &val2);
13196 if (!SWIG_IsOK(ecode2)) {
13197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13198 }
13199 arg2 = static_cast< long >(val2);
13200 }
13201 if (obj2) {
13202 ecode3 = SWIG_AsVal_int(obj2, &val3);
13203 if (!SWIG_IsOK(ecode3)) {
13204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13205 }
13206 arg3 = static_cast< int >(val3);
13207 }
13208 {
13209 PyThreadState* __tstate = wxPyBeginAllowThreads();
13210 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13215 {
13216 if (created1) delete arg1;
13217 }
13218 return resultobj;
13219 fail:
13220 {
13221 if (created1) delete arg1;
13222 }
13223 return NULL;
13224 }
13225
13226
13227 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13228 PyObject *resultobj = 0;
13229 wxInputStream *arg1 = 0 ;
13230 wxString *arg2 = 0 ;
13231 int arg3 = (int) -1 ;
13232 wxImage *result = 0 ;
13233 wxPyInputStream *temp1 ;
13234 bool created1 ;
13235 bool temp2 = false ;
13236 int val3 ;
13237 int ecode3 = 0 ;
13238 PyObject * obj0 = 0 ;
13239 PyObject * obj1 = 0 ;
13240 PyObject * obj2 = 0 ;
13241 char * kwnames[] = {
13242 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13243 };
13244
13245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13246 {
13247 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13248 arg1 = temp1->m_wxis;
13249 created1 = false;
13250 } else {
13251 PyErr_Clear(); // clear the failure of the wxPyConvert above
13252 arg1 = wxPyCBInputStream_create(obj0, false);
13253 if (arg1 == NULL) {
13254 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13255 SWIG_fail;
13256 }
13257 created1 = true;
13258 }
13259 }
13260 {
13261 arg2 = wxString_in_helper(obj1);
13262 if (arg2 == NULL) SWIG_fail;
13263 temp2 = true;
13264 }
13265 if (obj2) {
13266 ecode3 = SWIG_AsVal_int(obj2, &val3);
13267 if (!SWIG_IsOK(ecode3)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13269 }
13270 arg3 = static_cast< int >(val3);
13271 }
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13279 {
13280 if (created1) delete arg1;
13281 }
13282 {
13283 if (temp2)
13284 delete arg2;
13285 }
13286 return resultobj;
13287 fail:
13288 {
13289 if (created1) delete arg1;
13290 }
13291 {
13292 if (temp2)
13293 delete arg2;
13294 }
13295 return NULL;
13296 }
13297
13298
13299 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13300 PyObject *resultobj = 0;
13301 int arg1 = (int) 0 ;
13302 int arg2 = (int) 0 ;
13303 bool arg3 = (bool) true ;
13304 wxImage *result = 0 ;
13305 int val1 ;
13306 int ecode1 = 0 ;
13307 int val2 ;
13308 int ecode2 = 0 ;
13309 bool val3 ;
13310 int ecode3 = 0 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "width",(char *) "height",(char *) "clear", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13319 if (obj0) {
13320 ecode1 = SWIG_AsVal_int(obj0, &val1);
13321 if (!SWIG_IsOK(ecode1)) {
13322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13323 }
13324 arg1 = static_cast< int >(val1);
13325 }
13326 if (obj1) {
13327 ecode2 = SWIG_AsVal_int(obj1, &val2);
13328 if (!SWIG_IsOK(ecode2)) {
13329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13330 }
13331 arg2 = static_cast< int >(val2);
13332 }
13333 if (obj2) {
13334 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13335 if (!SWIG_IsOK(ecode3)) {
13336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13337 }
13338 arg3 = static_cast< bool >(val3);
13339 }
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13343 wxPyEndAllowThreads(__tstate);
13344 if (PyErr_Occurred()) SWIG_fail;
13345 }
13346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13347 return resultobj;
13348 fail:
13349 return NULL;
13350 }
13351
13352
13353 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13354 PyObject *resultobj = 0;
13355 wxBitmap *arg1 = 0 ;
13356 wxImage *result = 0 ;
13357 void *argp1 = 0 ;
13358 int res1 = 0 ;
13359 PyObject * obj0 = 0 ;
13360 char * kwnames[] = {
13361 (char *) "bitmap", NULL
13362 };
13363
13364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13365 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13366 if (!SWIG_IsOK(res1)) {
13367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13368 }
13369 if (!argp1) {
13370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13371 }
13372 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13373 {
13374 if (!wxPyCheckForApp()) SWIG_fail;
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj = 0;
13389 int arg1 ;
13390 int arg2 ;
13391 buffer arg3 ;
13392 int arg4 ;
13393 wxImage *result = 0 ;
13394 int val1 ;
13395 int ecode1 = 0 ;
13396 int val2 ;
13397 int ecode2 = 0 ;
13398 PyObject * obj0 = 0 ;
13399 PyObject * obj1 = 0 ;
13400 PyObject * obj2 = 0 ;
13401 char * kwnames[] = {
13402 (char *) "width",(char *) "height",(char *) "data", NULL
13403 };
13404
13405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13406 ecode1 = SWIG_AsVal_int(obj0, &val1);
13407 if (!SWIG_IsOK(ecode1)) {
13408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13409 }
13410 arg1 = static_cast< int >(val1);
13411 ecode2 = SWIG_AsVal_int(obj1, &val2);
13412 if (!SWIG_IsOK(ecode2)) {
13413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13414 }
13415 arg2 = static_cast< int >(val2);
13416 {
13417 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
13418 }
13419 {
13420 PyThreadState* __tstate = wxPyBeginAllowThreads();
13421 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13422 wxPyEndAllowThreads(__tstate);
13423 if (PyErr_Occurred()) SWIG_fail;
13424 }
13425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13426 return resultobj;
13427 fail:
13428 return NULL;
13429 }
13430
13431
13432 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13433 PyObject *resultobj = 0;
13434 int arg1 ;
13435 int arg2 ;
13436 buffer arg3 ;
13437 int arg4 ;
13438 buffer arg5 ;
13439 int arg6 ;
13440 wxImage *result = 0 ;
13441 int val1 ;
13442 int ecode1 = 0 ;
13443 int val2 ;
13444 int ecode2 = 0 ;
13445 PyObject * obj0 = 0 ;
13446 PyObject * obj1 = 0 ;
13447 PyObject * obj2 = 0 ;
13448 PyObject * obj3 = 0 ;
13449 char * kwnames[] = {
13450 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13451 };
13452
13453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13454 ecode1 = SWIG_AsVal_int(obj0, &val1);
13455 if (!SWIG_IsOK(ecode1)) {
13456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13457 }
13458 arg1 = static_cast< int >(val1);
13459 ecode2 = SWIG_AsVal_int(obj1, &val2);
13460 if (!SWIG_IsOK(ecode2)) {
13461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13462 }
13463 arg2 = static_cast< int >(val2);
13464 {
13465 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
13466 }
13467 {
13468 if (obj3 != Py_None) {
13469 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &arg6) == -1) SWIG_fail;
13470 }
13471 }
13472 {
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj = 0;
13487 wxImage *arg1 = (wxImage *) 0 ;
13488 int arg2 ;
13489 int arg3 ;
13490 bool arg4 = (bool) true ;
13491 void *argp1 = 0 ;
13492 int res1 = 0 ;
13493 int val2 ;
13494 int ecode2 = 0 ;
13495 int val3 ;
13496 int ecode3 = 0 ;
13497 bool val4 ;
13498 int ecode4 = 0 ;
13499 PyObject * obj0 = 0 ;
13500 PyObject * obj1 = 0 ;
13501 PyObject * obj2 = 0 ;
13502 PyObject * obj3 = 0 ;
13503 char * kwnames[] = {
13504 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13505 };
13506
13507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13509 if (!SWIG_IsOK(res1)) {
13510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13511 }
13512 arg1 = reinterpret_cast< wxImage * >(argp1);
13513 ecode2 = SWIG_AsVal_int(obj1, &val2);
13514 if (!SWIG_IsOK(ecode2)) {
13515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13516 }
13517 arg2 = static_cast< int >(val2);
13518 ecode3 = SWIG_AsVal_int(obj2, &val3);
13519 if (!SWIG_IsOK(ecode3)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13521 }
13522 arg3 = static_cast< int >(val3);
13523 if (obj3) {
13524 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13525 if (!SWIG_IsOK(ecode4)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13527 }
13528 arg4 = static_cast< bool >(val4);
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 (arg1)->Create(arg2,arg3,arg4);
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 resultobj = SWIG_Py_Void();
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13544 PyObject *resultobj = 0;
13545 wxImage *arg1 = (wxImage *) 0 ;
13546 void *argp1 = 0 ;
13547 int res1 = 0 ;
13548 PyObject *swig_obj[1] ;
13549
13550 if (!args) SWIG_fail;
13551 swig_obj[0] = args;
13552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13553 if (!SWIG_IsOK(res1)) {
13554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13555 }
13556 arg1 = reinterpret_cast< wxImage * >(argp1);
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 (arg1)->Destroy();
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 resultobj = SWIG_Py_Void();
13564 return resultobj;
13565 fail:
13566 return NULL;
13567 }
13568
13569
13570 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj = 0;
13572 wxImage *arg1 = (wxImage *) 0 ;
13573 int arg2 ;
13574 int arg3 ;
13575 SwigValueWrapper<wxImage > result;
13576 void *argp1 = 0 ;
13577 int res1 = 0 ;
13578 int val2 ;
13579 int ecode2 = 0 ;
13580 int val3 ;
13581 int ecode3 = 0 ;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 PyObject * obj2 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "self",(char *) "width",(char *) "height", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13591 if (!SWIG_IsOK(res1)) {
13592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13593 }
13594 arg1 = reinterpret_cast< wxImage * >(argp1);
13595 ecode2 = SWIG_AsVal_int(obj1, &val2);
13596 if (!SWIG_IsOK(ecode2)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13598 }
13599 arg2 = static_cast< int >(val2);
13600 ecode3 = SWIG_AsVal_int(obj2, &val3);
13601 if (!SWIG_IsOK(ecode3)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13603 }
13604 arg3 = static_cast< int >(val3);
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (arg1)->Scale(arg2,arg3);
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj = 0;
13620 wxImage *arg1 = (wxImage *) 0 ;
13621 int arg2 ;
13622 int arg3 ;
13623 SwigValueWrapper<wxImage > result;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 int val2 ;
13627 int ecode2 = 0 ;
13628 int val3 ;
13629 int ecode3 = 0 ;
13630 PyObject * obj0 = 0 ;
13631 PyObject * obj1 = 0 ;
13632 PyObject * obj2 = 0 ;
13633 char * kwnames[] = {
13634 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13635 };
13636
13637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13639 if (!SWIG_IsOK(res1)) {
13640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13641 }
13642 arg1 = reinterpret_cast< wxImage * >(argp1);
13643 ecode2 = SWIG_AsVal_int(obj1, &val2);
13644 if (!SWIG_IsOK(ecode2)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13646 }
13647 arg2 = static_cast< int >(val2);
13648 ecode3 = SWIG_AsVal_int(obj2, &val3);
13649 if (!SWIG_IsOK(ecode3)) {
13650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13651 }
13652 arg3 = static_cast< int >(val3);
13653 {
13654 PyThreadState* __tstate = wxPyBeginAllowThreads();
13655 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13656 wxPyEndAllowThreads(__tstate);
13657 if (PyErr_Occurred()) SWIG_fail;
13658 }
13659 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13660 return resultobj;
13661 fail:
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxImage *arg1 = (wxImage *) 0 ;
13669 int arg2 ;
13670 int arg3 ;
13671 wxImage *result = 0 ;
13672 void *argp1 = 0 ;
13673 int res1 = 0 ;
13674 int val2 ;
13675 int ecode2 = 0 ;
13676 int val3 ;
13677 int ecode3 = 0 ;
13678 PyObject * obj0 = 0 ;
13679 PyObject * obj1 = 0 ;
13680 PyObject * obj2 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "self",(char *) "width",(char *) "height", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13687 if (!SWIG_IsOK(res1)) {
13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13689 }
13690 arg1 = reinterpret_cast< wxImage * >(argp1);
13691 ecode2 = SWIG_AsVal_int(obj1, &val2);
13692 if (!SWIG_IsOK(ecode2)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13694 }
13695 arg2 = static_cast< int >(val2);
13696 ecode3 = SWIG_AsVal_int(obj2, &val3);
13697 if (!SWIG_IsOK(ecode3)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13699 }
13700 arg3 = static_cast< int >(val3);
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 {
13704 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13705 result = (wxImage *) &_result_ref;
13706 }
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13711 return resultobj;
13712 fail:
13713 return NULL;
13714 }
13715
13716
13717 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj = 0;
13719 wxImage *arg1 = (wxImage *) 0 ;
13720 wxSize *arg2 = 0 ;
13721 wxPoint *arg3 = 0 ;
13722 int arg4 = (int) -1 ;
13723 int arg5 = (int) -1 ;
13724 int arg6 = (int) -1 ;
13725 wxImage *result = 0 ;
13726 void *argp1 = 0 ;
13727 int res1 = 0 ;
13728 wxSize temp2 ;
13729 wxPoint temp3 ;
13730 int val4 ;
13731 int ecode4 = 0 ;
13732 int val5 ;
13733 int ecode5 = 0 ;
13734 int val6 ;
13735 int ecode6 = 0 ;
13736 PyObject * obj0 = 0 ;
13737 PyObject * obj1 = 0 ;
13738 PyObject * obj2 = 0 ;
13739 PyObject * obj3 = 0 ;
13740 PyObject * obj4 = 0 ;
13741 PyObject * obj5 = 0 ;
13742 char * kwnames[] = {
13743 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13744 };
13745
13746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13748 if (!SWIG_IsOK(res1)) {
13749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13750 }
13751 arg1 = reinterpret_cast< wxImage * >(argp1);
13752 {
13753 arg2 = &temp2;
13754 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13755 }
13756 {
13757 arg3 = &temp3;
13758 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13759 }
13760 if (obj3) {
13761 ecode4 = SWIG_AsVal_int(obj3, &val4);
13762 if (!SWIG_IsOK(ecode4)) {
13763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13764 }
13765 arg4 = static_cast< int >(val4);
13766 }
13767 if (obj4) {
13768 ecode5 = SWIG_AsVal_int(obj4, &val5);
13769 if (!SWIG_IsOK(ecode5)) {
13770 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13771 }
13772 arg5 = static_cast< int >(val5);
13773 }
13774 if (obj5) {
13775 ecode6 = SWIG_AsVal_int(obj5, &val6);
13776 if (!SWIG_IsOK(ecode6)) {
13777 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13778 }
13779 arg6 = static_cast< int >(val6);
13780 }
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 {
13784 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13785 result = (wxImage *) &_result_ref;
13786 }
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = 0;
13799 wxImage *arg1 = (wxImage *) 0 ;
13800 int arg2 ;
13801 int arg3 ;
13802 byte arg4 ;
13803 byte arg5 ;
13804 byte arg6 ;
13805 void *argp1 = 0 ;
13806 int res1 = 0 ;
13807 int val2 ;
13808 int ecode2 = 0 ;
13809 int val3 ;
13810 int ecode3 = 0 ;
13811 unsigned char val4 ;
13812 int ecode4 = 0 ;
13813 unsigned char val5 ;
13814 int ecode5 = 0 ;
13815 unsigned char val6 ;
13816 int ecode6 = 0 ;
13817 PyObject * obj0 = 0 ;
13818 PyObject * obj1 = 0 ;
13819 PyObject * obj2 = 0 ;
13820 PyObject * obj3 = 0 ;
13821 PyObject * obj4 = 0 ;
13822 PyObject * obj5 = 0 ;
13823 char * kwnames[] = {
13824 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13825 };
13826
13827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13829 if (!SWIG_IsOK(res1)) {
13830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13831 }
13832 arg1 = reinterpret_cast< wxImage * >(argp1);
13833 ecode2 = SWIG_AsVal_int(obj1, &val2);
13834 if (!SWIG_IsOK(ecode2)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13836 }
13837 arg2 = static_cast< int >(val2);
13838 ecode3 = SWIG_AsVal_int(obj2, &val3);
13839 if (!SWIG_IsOK(ecode3)) {
13840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13841 }
13842 arg3 = static_cast< int >(val3);
13843 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13844 if (!SWIG_IsOK(ecode4)) {
13845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13846 }
13847 arg4 = static_cast< byte >(val4);
13848 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13849 if (!SWIG_IsOK(ecode5)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13851 }
13852 arg5 = static_cast< byte >(val5);
13853 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13854 if (!SWIG_IsOK(ecode6)) {
13855 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13856 }
13857 arg6 = static_cast< byte >(val6);
13858 {
13859 PyThreadState* __tstate = wxPyBeginAllowThreads();
13860 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_Py_Void();
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13872 PyObject *resultobj = 0;
13873 wxImage *arg1 = (wxImage *) 0 ;
13874 wxRect *arg2 = 0 ;
13875 byte arg3 ;
13876 byte arg4 ;
13877 byte arg5 ;
13878 void *argp1 = 0 ;
13879 int res1 = 0 ;
13880 wxRect temp2 ;
13881 unsigned char val3 ;
13882 int ecode3 = 0 ;
13883 unsigned char val4 ;
13884 int ecode4 = 0 ;
13885 unsigned char val5 ;
13886 int ecode5 = 0 ;
13887 PyObject * obj0 = 0 ;
13888 PyObject * obj1 = 0 ;
13889 PyObject * obj2 = 0 ;
13890 PyObject * obj3 = 0 ;
13891 PyObject * obj4 = 0 ;
13892 char * kwnames[] = {
13893 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13894 };
13895
13896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13898 if (!SWIG_IsOK(res1)) {
13899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13900 }
13901 arg1 = reinterpret_cast< wxImage * >(argp1);
13902 {
13903 arg2 = &temp2;
13904 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13905 }
13906 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13907 if (!SWIG_IsOK(ecode3)) {
13908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13909 }
13910 arg3 = static_cast< byte >(val3);
13911 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13912 if (!SWIG_IsOK(ecode4)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13914 }
13915 arg4 = static_cast< byte >(val4);
13916 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13917 if (!SWIG_IsOK(ecode5)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13919 }
13920 arg5 = static_cast< byte >(val5);
13921 {
13922 PyThreadState* __tstate = wxPyBeginAllowThreads();
13923 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13924 wxPyEndAllowThreads(__tstate);
13925 if (PyErr_Occurred()) SWIG_fail;
13926 }
13927 resultobj = SWIG_Py_Void();
13928 return resultobj;
13929 fail:
13930 return NULL;
13931 }
13932
13933
13934 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13935 PyObject *resultobj = 0;
13936 wxImage *arg1 = (wxImage *) 0 ;
13937 int arg2 ;
13938 int arg3 ;
13939 byte result;
13940 void *argp1 = 0 ;
13941 int res1 = 0 ;
13942 int val2 ;
13943 int ecode2 = 0 ;
13944 int val3 ;
13945 int ecode3 = 0 ;
13946 PyObject * obj0 = 0 ;
13947 PyObject * obj1 = 0 ;
13948 PyObject * obj2 = 0 ;
13949 char * kwnames[] = {
13950 (char *) "self",(char *) "x",(char *) "y", NULL
13951 };
13952
13953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13955 if (!SWIG_IsOK(res1)) {
13956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13957 }
13958 arg1 = reinterpret_cast< wxImage * >(argp1);
13959 ecode2 = SWIG_AsVal_int(obj1, &val2);
13960 if (!SWIG_IsOK(ecode2)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13962 }
13963 arg2 = static_cast< int >(val2);
13964 ecode3 = SWIG_AsVal_int(obj2, &val3);
13965 if (!SWIG_IsOK(ecode3)) {
13966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13967 }
13968 arg3 = static_cast< int >(val3);
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 result = (byte)(arg1)->GetRed(arg2,arg3);
13972 wxPyEndAllowThreads(__tstate);
13973 if (PyErr_Occurred()) SWIG_fail;
13974 }
13975 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13976 return resultobj;
13977 fail:
13978 return NULL;
13979 }
13980
13981
13982 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj = 0;
13984 wxImage *arg1 = (wxImage *) 0 ;
13985 int arg2 ;
13986 int arg3 ;
13987 byte result;
13988 void *argp1 = 0 ;
13989 int res1 = 0 ;
13990 int val2 ;
13991 int ecode2 = 0 ;
13992 int val3 ;
13993 int ecode3 = 0 ;
13994 PyObject * obj0 = 0 ;
13995 PyObject * obj1 = 0 ;
13996 PyObject * obj2 = 0 ;
13997 char * kwnames[] = {
13998 (char *) "self",(char *) "x",(char *) "y", NULL
13999 };
14000
14001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14003 if (!SWIG_IsOK(res1)) {
14004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14005 }
14006 arg1 = reinterpret_cast< wxImage * >(argp1);
14007 ecode2 = SWIG_AsVal_int(obj1, &val2);
14008 if (!SWIG_IsOK(ecode2)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14010 }
14011 arg2 = static_cast< int >(val2);
14012 ecode3 = SWIG_AsVal_int(obj2, &val3);
14013 if (!SWIG_IsOK(ecode3)) {
14014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14015 }
14016 arg3 = static_cast< int >(val3);
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 result = (byte)(arg1)->GetGreen(arg2,arg3);
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14024 return resultobj;
14025 fail:
14026 return NULL;
14027 }
14028
14029
14030 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14031 PyObject *resultobj = 0;
14032 wxImage *arg1 = (wxImage *) 0 ;
14033 int arg2 ;
14034 int arg3 ;
14035 byte result;
14036 void *argp1 = 0 ;
14037 int res1 = 0 ;
14038 int val2 ;
14039 int ecode2 = 0 ;
14040 int val3 ;
14041 int ecode3 = 0 ;
14042 PyObject * obj0 = 0 ;
14043 PyObject * obj1 = 0 ;
14044 PyObject * obj2 = 0 ;
14045 char * kwnames[] = {
14046 (char *) "self",(char *) "x",(char *) "y", NULL
14047 };
14048
14049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14051 if (!SWIG_IsOK(res1)) {
14052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14053 }
14054 arg1 = reinterpret_cast< wxImage * >(argp1);
14055 ecode2 = SWIG_AsVal_int(obj1, &val2);
14056 if (!SWIG_IsOK(ecode2)) {
14057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14058 }
14059 arg2 = static_cast< int >(val2);
14060 ecode3 = SWIG_AsVal_int(obj2, &val3);
14061 if (!SWIG_IsOK(ecode3)) {
14062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14063 }
14064 arg3 = static_cast< int >(val3);
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 result = (byte)(arg1)->GetBlue(arg2,arg3);
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14072 return resultobj;
14073 fail:
14074 return NULL;
14075 }
14076
14077
14078 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14079 PyObject *resultobj = 0;
14080 wxImage *arg1 = (wxImage *) 0 ;
14081 int arg2 ;
14082 int arg3 ;
14083 byte arg4 ;
14084 void *argp1 = 0 ;
14085 int res1 = 0 ;
14086 int val2 ;
14087 int ecode2 = 0 ;
14088 int val3 ;
14089 int ecode3 = 0 ;
14090 unsigned char val4 ;
14091 int ecode4 = 0 ;
14092 PyObject * obj0 = 0 ;
14093 PyObject * obj1 = 0 ;
14094 PyObject * obj2 = 0 ;
14095 PyObject * obj3 = 0 ;
14096 char * kwnames[] = {
14097 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14098 };
14099
14100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14102 if (!SWIG_IsOK(res1)) {
14103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14104 }
14105 arg1 = reinterpret_cast< wxImage * >(argp1);
14106 ecode2 = SWIG_AsVal_int(obj1, &val2);
14107 if (!SWIG_IsOK(ecode2)) {
14108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14109 }
14110 arg2 = static_cast< int >(val2);
14111 ecode3 = SWIG_AsVal_int(obj2, &val3);
14112 if (!SWIG_IsOK(ecode3)) {
14113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14114 }
14115 arg3 = static_cast< int >(val3);
14116 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14117 if (!SWIG_IsOK(ecode4)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14119 }
14120 arg4 = static_cast< byte >(val4);
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 (arg1)->SetAlpha(arg2,arg3,arg4);
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 resultobj = SWIG_Py_Void();
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxImage *arg1 = (wxImage *) 0 ;
14137 int arg2 ;
14138 int arg3 ;
14139 byte result;
14140 void *argp1 = 0 ;
14141 int res1 = 0 ;
14142 int val2 ;
14143 int ecode2 = 0 ;
14144 int val3 ;
14145 int ecode3 = 0 ;
14146 PyObject * obj0 = 0 ;
14147 PyObject * obj1 = 0 ;
14148 PyObject * obj2 = 0 ;
14149 char * kwnames[] = {
14150 (char *) "self",(char *) "x",(char *) "y", NULL
14151 };
14152
14153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14155 if (!SWIG_IsOK(res1)) {
14156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14157 }
14158 arg1 = reinterpret_cast< wxImage * >(argp1);
14159 ecode2 = SWIG_AsVal_int(obj1, &val2);
14160 if (!SWIG_IsOK(ecode2)) {
14161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14162 }
14163 arg2 = static_cast< int >(val2);
14164 ecode3 = SWIG_AsVal_int(obj2, &val3);
14165 if (!SWIG_IsOK(ecode3)) {
14166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14167 }
14168 arg3 = static_cast< int >(val3);
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 PyObject *resultobj = 0;
14184 wxImage *arg1 = (wxImage *) 0 ;
14185 bool result;
14186 void *argp1 = 0 ;
14187 int res1 = 0 ;
14188 PyObject *swig_obj[1] ;
14189
14190 if (!args) SWIG_fail;
14191 swig_obj[0] = args;
14192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14193 if (!SWIG_IsOK(res1)) {
14194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14195 }
14196 arg1 = reinterpret_cast< wxImage * >(argp1);
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (bool)(arg1)->HasAlpha();
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14205 }
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14213 PyObject *resultobj = 0;
14214 wxImage *arg1 = (wxImage *) 0 ;
14215 void *argp1 = 0 ;
14216 int res1 = 0 ;
14217 PyObject *swig_obj[1] ;
14218
14219 if (!args) SWIG_fail;
14220 swig_obj[0] = args;
14221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14222 if (!SWIG_IsOK(res1)) {
14223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14224 }
14225 arg1 = reinterpret_cast< wxImage * >(argp1);
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 (arg1)->InitAlpha();
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 resultobj = SWIG_Py_Void();
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14240 PyObject *resultobj = 0;
14241 wxImage *arg1 = (wxImage *) 0 ;
14242 int arg2 ;
14243 int arg3 ;
14244 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14245 bool result;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 int val2 ;
14249 int ecode2 = 0 ;
14250 int val3 ;
14251 int ecode3 = 0 ;
14252 unsigned char val4 ;
14253 int ecode4 = 0 ;
14254 PyObject * obj0 = 0 ;
14255 PyObject * obj1 = 0 ;
14256 PyObject * obj2 = 0 ;
14257 PyObject * obj3 = 0 ;
14258 char * kwnames[] = {
14259 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14260 };
14261
14262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14264 if (!SWIG_IsOK(res1)) {
14265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14266 }
14267 arg1 = reinterpret_cast< wxImage * >(argp1);
14268 ecode2 = SWIG_AsVal_int(obj1, &val2);
14269 if (!SWIG_IsOK(ecode2)) {
14270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14271 }
14272 arg2 = static_cast< int >(val2);
14273 ecode3 = SWIG_AsVal_int(obj2, &val3);
14274 if (!SWIG_IsOK(ecode3)) {
14275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14276 }
14277 arg3 = static_cast< int >(val3);
14278 if (obj3) {
14279 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14280 if (!SWIG_IsOK(ecode4)) {
14281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14282 }
14283 arg4 = static_cast< byte >(val4);
14284 }
14285 {
14286 PyThreadState* __tstate = wxPyBeginAllowThreads();
14287 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14288 wxPyEndAllowThreads(__tstate);
14289 if (PyErr_Occurred()) SWIG_fail;
14290 }
14291 {
14292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14293 }
14294 return resultobj;
14295 fail:
14296 return NULL;
14297 }
14298
14299
14300 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj = 0;
14302 wxImage *arg1 = (wxImage *) 0 ;
14303 byte *arg2 = (byte *) 0 ;
14304 byte *arg3 = (byte *) 0 ;
14305 byte *arg4 = (byte *) 0 ;
14306 byte arg5 = (byte) 0 ;
14307 byte arg6 = (byte) 0 ;
14308 byte arg7 = (byte) 0 ;
14309 bool result;
14310 void *argp1 = 0 ;
14311 int res1 = 0 ;
14312 byte temp2 ;
14313 int res2 = SWIG_TMPOBJ ;
14314 byte temp3 ;
14315 int res3 = SWIG_TMPOBJ ;
14316 byte temp4 ;
14317 int res4 = SWIG_TMPOBJ ;
14318 unsigned char val5 ;
14319 int ecode5 = 0 ;
14320 unsigned char val6 ;
14321 int ecode6 = 0 ;
14322 unsigned char val7 ;
14323 int ecode7 = 0 ;
14324 PyObject * obj0 = 0 ;
14325 PyObject * obj1 = 0 ;
14326 PyObject * obj2 = 0 ;
14327 PyObject * obj3 = 0 ;
14328 char * kwnames[] = {
14329 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14330 };
14331
14332 arg2 = &temp2;
14333 arg3 = &temp3;
14334 arg4 = &temp4;
14335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14337 if (!SWIG_IsOK(res1)) {
14338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14339 }
14340 arg1 = reinterpret_cast< wxImage * >(argp1);
14341 if (obj1) {
14342 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14343 if (!SWIG_IsOK(ecode5)) {
14344 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14345 }
14346 arg5 = static_cast< byte >(val5);
14347 }
14348 if (obj2) {
14349 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14350 if (!SWIG_IsOK(ecode6)) {
14351 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14352 }
14353 arg6 = static_cast< byte >(val6);
14354 }
14355 if (obj3) {
14356 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14357 if (!SWIG_IsOK(ecode7)) {
14358 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14359 }
14360 arg7 = static_cast< byte >(val7);
14361 }
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 {
14369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14370 }
14371 if (SWIG_IsTmpObj(res2)) {
14372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14373 } else {
14374 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14376 }
14377 if (SWIG_IsTmpObj(res3)) {
14378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14379 } else {
14380 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14382 }
14383 if (SWIG_IsTmpObj(res4)) {
14384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14385 } else {
14386 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14388 }
14389 return resultobj;
14390 fail:
14391 return NULL;
14392 }
14393
14394
14395 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14396 PyObject *resultobj = 0;
14397 wxImage *arg1 = (wxImage *) 0 ;
14398 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14399 bool result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 unsigned char val2 ;
14403 int ecode2 = 0 ;
14404 PyObject * obj0 = 0 ;
14405 PyObject * obj1 = 0 ;
14406 char * kwnames[] = {
14407 (char *) "self",(char *) "threshold", NULL
14408 };
14409
14410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14412 if (!SWIG_IsOK(res1)) {
14413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14414 }
14415 arg1 = reinterpret_cast< wxImage * >(argp1);
14416 if (obj1) {
14417 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14418 if (!SWIG_IsOK(ecode2)) {
14419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14420 }
14421 arg2 = static_cast< byte >(val2);
14422 }
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 {
14430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14431 }
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14439 PyObject *resultobj = 0;
14440 wxImage *arg1 = (wxImage *) 0 ;
14441 byte arg2 ;
14442 byte arg3 ;
14443 byte arg4 ;
14444 bool result;
14445 void *argp1 = 0 ;
14446 int res1 = 0 ;
14447 unsigned char val2 ;
14448 int ecode2 = 0 ;
14449 unsigned char val3 ;
14450 int ecode3 = 0 ;
14451 unsigned char val4 ;
14452 int ecode4 = 0 ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 PyObject * obj3 = 0 ;
14457 char * kwnames[] = {
14458 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14459 };
14460
14461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14463 if (!SWIG_IsOK(res1)) {
14464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14465 }
14466 arg1 = reinterpret_cast< wxImage * >(argp1);
14467 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14468 if (!SWIG_IsOK(ecode2)) {
14469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14470 }
14471 arg2 = static_cast< byte >(val2);
14472 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14473 if (!SWIG_IsOK(ecode3)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14475 }
14476 arg3 = static_cast< byte >(val3);
14477 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14478 if (!SWIG_IsOK(ecode4)) {
14479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14480 }
14481 arg4 = static_cast< byte >(val4);
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 {
14489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14490 }
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj = 0;
14499 wxImage *arg1 = (wxImage *) 0 ;
14500 wxImage *arg2 = 0 ;
14501 byte arg3 ;
14502 byte arg4 ;
14503 byte arg5 ;
14504 bool result;
14505 void *argp1 = 0 ;
14506 int res1 = 0 ;
14507 void *argp2 = 0 ;
14508 int res2 = 0 ;
14509 unsigned char val3 ;
14510 int ecode3 = 0 ;
14511 unsigned char val4 ;
14512 int ecode4 = 0 ;
14513 unsigned char val5 ;
14514 int ecode5 = 0 ;
14515 PyObject * obj0 = 0 ;
14516 PyObject * obj1 = 0 ;
14517 PyObject * obj2 = 0 ;
14518 PyObject * obj3 = 0 ;
14519 PyObject * obj4 = 0 ;
14520 char * kwnames[] = {
14521 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14522 };
14523
14524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14526 if (!SWIG_IsOK(res1)) {
14527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14528 }
14529 arg1 = reinterpret_cast< wxImage * >(argp1);
14530 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14531 if (!SWIG_IsOK(res2)) {
14532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14533 }
14534 if (!argp2) {
14535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14536 }
14537 arg2 = reinterpret_cast< wxImage * >(argp2);
14538 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14539 if (!SWIG_IsOK(ecode3)) {
14540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14541 }
14542 arg3 = static_cast< byte >(val3);
14543 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14544 if (!SWIG_IsOK(ecode4)) {
14545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14546 }
14547 arg4 = static_cast< byte >(val4);
14548 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14549 if (!SWIG_IsOK(ecode5)) {
14550 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14551 }
14552 arg5 = static_cast< byte >(val5);
14553 {
14554 PyThreadState* __tstate = wxPyBeginAllowThreads();
14555 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 {
14560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14561 }
14562 return resultobj;
14563 fail:
14564 return NULL;
14565 }
14566
14567
14568 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14569 PyObject *resultobj = 0;
14570 wxString *arg1 = 0 ;
14571 bool result;
14572 bool temp1 = false ;
14573 PyObject * obj0 = 0 ;
14574 char * kwnames[] = {
14575 (char *) "filename", NULL
14576 };
14577
14578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14579 {
14580 arg1 = wxString_in_helper(obj0);
14581 if (arg1 == NULL) SWIG_fail;
14582 temp1 = true;
14583 }
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 {
14591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14592 }
14593 {
14594 if (temp1)
14595 delete arg1;
14596 }
14597 return resultobj;
14598 fail:
14599 {
14600 if (temp1)
14601 delete arg1;
14602 }
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj = 0;
14609 wxString *arg1 = 0 ;
14610 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14611 int result;
14612 bool temp1 = false ;
14613 long val2 ;
14614 int ecode2 = 0 ;
14615 PyObject * obj0 = 0 ;
14616 PyObject * obj1 = 0 ;
14617 char * kwnames[] = {
14618 (char *) "filename",(char *) "type", NULL
14619 };
14620
14621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14622 {
14623 arg1 = wxString_in_helper(obj0);
14624 if (arg1 == NULL) SWIG_fail;
14625 temp1 = true;
14626 }
14627 if (obj1) {
14628 ecode2 = SWIG_AsVal_long(obj1, &val2);
14629 if (!SWIG_IsOK(ecode2)) {
14630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14631 }
14632 arg2 = static_cast< long >(val2);
14633 }
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14637 wxPyEndAllowThreads(__tstate);
14638 if (PyErr_Occurred()) SWIG_fail;
14639 }
14640 resultobj = SWIG_From_int(static_cast< int >(result));
14641 {
14642 if (temp1)
14643 delete arg1;
14644 }
14645 return resultobj;
14646 fail:
14647 {
14648 if (temp1)
14649 delete arg1;
14650 }
14651 return NULL;
14652 }
14653
14654
14655 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14656 PyObject *resultobj = 0;
14657 wxImage *arg1 = (wxImage *) 0 ;
14658 wxString *arg2 = 0 ;
14659 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14660 int arg4 = (int) -1 ;
14661 bool result;
14662 void *argp1 = 0 ;
14663 int res1 = 0 ;
14664 bool temp2 = false ;
14665 long val3 ;
14666 int ecode3 = 0 ;
14667 int val4 ;
14668 int ecode4 = 0 ;
14669 PyObject * obj0 = 0 ;
14670 PyObject * obj1 = 0 ;
14671 PyObject * obj2 = 0 ;
14672 PyObject * obj3 = 0 ;
14673 char * kwnames[] = {
14674 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14675 };
14676
14677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14679 if (!SWIG_IsOK(res1)) {
14680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14681 }
14682 arg1 = reinterpret_cast< wxImage * >(argp1);
14683 {
14684 arg2 = wxString_in_helper(obj1);
14685 if (arg2 == NULL) SWIG_fail;
14686 temp2 = true;
14687 }
14688 if (obj2) {
14689 ecode3 = SWIG_AsVal_long(obj2, &val3);
14690 if (!SWIG_IsOK(ecode3)) {
14691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14692 }
14693 arg3 = static_cast< long >(val3);
14694 }
14695 if (obj3) {
14696 ecode4 = SWIG_AsVal_int(obj3, &val4);
14697 if (!SWIG_IsOK(ecode4)) {
14698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14699 }
14700 arg4 = static_cast< int >(val4);
14701 }
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14705 wxPyEndAllowThreads(__tstate);
14706 if (PyErr_Occurred()) SWIG_fail;
14707 }
14708 {
14709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14710 }
14711 {
14712 if (temp2)
14713 delete arg2;
14714 }
14715 return resultobj;
14716 fail:
14717 {
14718 if (temp2)
14719 delete arg2;
14720 }
14721 return NULL;
14722 }
14723
14724
14725 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14726 PyObject *resultobj = 0;
14727 wxImage *arg1 = (wxImage *) 0 ;
14728 wxString *arg2 = 0 ;
14729 wxString *arg3 = 0 ;
14730 int arg4 = (int) -1 ;
14731 bool result;
14732 void *argp1 = 0 ;
14733 int res1 = 0 ;
14734 bool temp2 = false ;
14735 bool temp3 = false ;
14736 int val4 ;
14737 int ecode4 = 0 ;
14738 PyObject * obj0 = 0 ;
14739 PyObject * obj1 = 0 ;
14740 PyObject * obj2 = 0 ;
14741 PyObject * obj3 = 0 ;
14742 char * kwnames[] = {
14743 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14744 };
14745
14746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14748 if (!SWIG_IsOK(res1)) {
14749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14750 }
14751 arg1 = reinterpret_cast< wxImage * >(argp1);
14752 {
14753 arg2 = wxString_in_helper(obj1);
14754 if (arg2 == NULL) SWIG_fail;
14755 temp2 = true;
14756 }
14757 {
14758 arg3 = wxString_in_helper(obj2);
14759 if (arg3 == NULL) SWIG_fail;
14760 temp3 = true;
14761 }
14762 if (obj3) {
14763 ecode4 = SWIG_AsVal_int(obj3, &val4);
14764 if (!SWIG_IsOK(ecode4)) {
14765 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14766 }
14767 arg4 = static_cast< int >(val4);
14768 }
14769 {
14770 PyThreadState* __tstate = wxPyBeginAllowThreads();
14771 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14772 wxPyEndAllowThreads(__tstate);
14773 if (PyErr_Occurred()) SWIG_fail;
14774 }
14775 {
14776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14777 }
14778 {
14779 if (temp2)
14780 delete arg2;
14781 }
14782 {
14783 if (temp3)
14784 delete arg3;
14785 }
14786 return resultobj;
14787 fail:
14788 {
14789 if (temp2)
14790 delete arg2;
14791 }
14792 {
14793 if (temp3)
14794 delete arg3;
14795 }
14796 return NULL;
14797 }
14798
14799
14800 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14801 PyObject *resultobj = 0;
14802 wxImage *arg1 = (wxImage *) 0 ;
14803 wxString *arg2 = 0 ;
14804 int arg3 ;
14805 bool result;
14806 void *argp1 = 0 ;
14807 int res1 = 0 ;
14808 bool temp2 = false ;
14809 int val3 ;
14810 int ecode3 = 0 ;
14811 PyObject * obj0 = 0 ;
14812 PyObject * obj1 = 0 ;
14813 PyObject * obj2 = 0 ;
14814 char * kwnames[] = {
14815 (char *) "self",(char *) "name",(char *) "type", NULL
14816 };
14817
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImage * >(argp1);
14824 {
14825 arg2 = wxString_in_helper(obj1);
14826 if (arg2 == NULL) SWIG_fail;
14827 temp2 = true;
14828 }
14829 ecode3 = SWIG_AsVal_int(obj2, &val3);
14830 if (!SWIG_IsOK(ecode3)) {
14831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14832 }
14833 arg3 = static_cast< int >(val3);
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14837 wxPyEndAllowThreads(__tstate);
14838 if (PyErr_Occurred()) SWIG_fail;
14839 }
14840 {
14841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14842 }
14843 {
14844 if (temp2)
14845 delete arg2;
14846 }
14847 return resultobj;
14848 fail:
14849 {
14850 if (temp2)
14851 delete arg2;
14852 }
14853 return NULL;
14854 }
14855
14856
14857 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14858 PyObject *resultobj = 0;
14859 wxImage *arg1 = (wxImage *) 0 ;
14860 wxString *arg2 = 0 ;
14861 wxString *arg3 = 0 ;
14862 bool result;
14863 void *argp1 = 0 ;
14864 int res1 = 0 ;
14865 bool temp2 = false ;
14866 bool temp3 = false ;
14867 PyObject * obj0 = 0 ;
14868 PyObject * obj1 = 0 ;
14869 PyObject * obj2 = 0 ;
14870 char * kwnames[] = {
14871 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14872 };
14873
14874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14876 if (!SWIG_IsOK(res1)) {
14877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14878 }
14879 arg1 = reinterpret_cast< wxImage * >(argp1);
14880 {
14881 arg2 = wxString_in_helper(obj1);
14882 if (arg2 == NULL) SWIG_fail;
14883 temp2 = true;
14884 }
14885 {
14886 arg3 = wxString_in_helper(obj2);
14887 if (arg3 == NULL) SWIG_fail;
14888 temp3 = true;
14889 }
14890 {
14891 PyThreadState* __tstate = wxPyBeginAllowThreads();
14892 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14893 wxPyEndAllowThreads(__tstate);
14894 if (PyErr_Occurred()) SWIG_fail;
14895 }
14896 {
14897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14898 }
14899 {
14900 if (temp2)
14901 delete arg2;
14902 }
14903 {
14904 if (temp3)
14905 delete arg3;
14906 }
14907 return resultobj;
14908 fail:
14909 {
14910 if (temp2)
14911 delete arg2;
14912 }
14913 {
14914 if (temp3)
14915 delete arg3;
14916 }
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14922 PyObject *resultobj = 0;
14923 wxInputStream *arg1 = 0 ;
14924 bool result;
14925 wxPyInputStream *temp1 ;
14926 bool created1 ;
14927 PyObject * obj0 = 0 ;
14928 char * kwnames[] = {
14929 (char *) "stream", NULL
14930 };
14931
14932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14933 {
14934 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14935 arg1 = temp1->m_wxis;
14936 created1 = false;
14937 } else {
14938 PyErr_Clear(); // clear the failure of the wxPyConvert above
14939 arg1 = wxPyCBInputStream_create(obj0, false);
14940 if (arg1 == NULL) {
14941 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14942 SWIG_fail;
14943 }
14944 created1 = true;
14945 }
14946 }
14947 {
14948 PyThreadState* __tstate = wxPyBeginAllowThreads();
14949 result = (bool)wxImage::CanRead(*arg1);
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 {
14954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14955 }
14956 {
14957 if (created1) delete arg1;
14958 }
14959 return resultobj;
14960 fail:
14961 {
14962 if (created1) delete arg1;
14963 }
14964 return NULL;
14965 }
14966
14967
14968 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14969 PyObject *resultobj = 0;
14970 wxImage *arg1 = (wxImage *) 0 ;
14971 wxInputStream *arg2 = 0 ;
14972 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14973 int arg4 = (int) -1 ;
14974 bool result;
14975 void *argp1 = 0 ;
14976 int res1 = 0 ;
14977 wxPyInputStream *temp2 ;
14978 bool created2 ;
14979 long val3 ;
14980 int ecode3 = 0 ;
14981 int val4 ;
14982 int ecode4 = 0 ;
14983 PyObject * obj0 = 0 ;
14984 PyObject * obj1 = 0 ;
14985 PyObject * obj2 = 0 ;
14986 PyObject * obj3 = 0 ;
14987 char * kwnames[] = {
14988 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14989 };
14990
14991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14993 if (!SWIG_IsOK(res1)) {
14994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14995 }
14996 arg1 = reinterpret_cast< wxImage * >(argp1);
14997 {
14998 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14999 arg2 = temp2->m_wxis;
15000 created2 = false;
15001 } else {
15002 PyErr_Clear(); // clear the failure of the wxPyConvert above
15003 arg2 = wxPyCBInputStream_create(obj1, false);
15004 if (arg2 == NULL) {
15005 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15006 SWIG_fail;
15007 }
15008 created2 = true;
15009 }
15010 }
15011 if (obj2) {
15012 ecode3 = SWIG_AsVal_long(obj2, &val3);
15013 if (!SWIG_IsOK(ecode3)) {
15014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15015 }
15016 arg3 = static_cast< long >(val3);
15017 }
15018 if (obj3) {
15019 ecode4 = SWIG_AsVal_int(obj3, &val4);
15020 if (!SWIG_IsOK(ecode4)) {
15021 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15022 }
15023 arg4 = static_cast< int >(val4);
15024 }
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 {
15032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15033 }
15034 {
15035 if (created2) delete arg2;
15036 }
15037 return resultobj;
15038 fail:
15039 {
15040 if (created2) delete arg2;
15041 }
15042 return NULL;
15043 }
15044
15045
15046 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15047 PyObject *resultobj = 0;
15048 wxImage *arg1 = (wxImage *) 0 ;
15049 wxInputStream *arg2 = 0 ;
15050 wxString *arg3 = 0 ;
15051 int arg4 = (int) -1 ;
15052 bool result;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 wxPyInputStream *temp2 ;
15056 bool created2 ;
15057 bool temp3 = false ;
15058 int val4 ;
15059 int ecode4 = 0 ;
15060 PyObject * obj0 = 0 ;
15061 PyObject * obj1 = 0 ;
15062 PyObject * obj2 = 0 ;
15063 PyObject * obj3 = 0 ;
15064 char * kwnames[] = {
15065 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15066 };
15067
15068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15072 }
15073 arg1 = reinterpret_cast< wxImage * >(argp1);
15074 {
15075 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15076 arg2 = temp2->m_wxis;
15077 created2 = false;
15078 } else {
15079 PyErr_Clear(); // clear the failure of the wxPyConvert above
15080 arg2 = wxPyCBInputStream_create(obj1, false);
15081 if (arg2 == NULL) {
15082 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15083 SWIG_fail;
15084 }
15085 created2 = true;
15086 }
15087 }
15088 {
15089 arg3 = wxString_in_helper(obj2);
15090 if (arg3 == NULL) SWIG_fail;
15091 temp3 = true;
15092 }
15093 if (obj3) {
15094 ecode4 = SWIG_AsVal_int(obj3, &val4);
15095 if (!SWIG_IsOK(ecode4)) {
15096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15097 }
15098 arg4 = static_cast< int >(val4);
15099 }
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 {
15107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15108 }
15109 {
15110 if (created2) delete arg2;
15111 }
15112 {
15113 if (temp3)
15114 delete arg3;
15115 }
15116 return resultobj;
15117 fail:
15118 {
15119 if (created2) delete arg2;
15120 }
15121 {
15122 if (temp3)
15123 delete arg3;
15124 }
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15130 PyObject *resultobj = 0;
15131 wxImage *arg1 = (wxImage *) 0 ;
15132 bool result;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 PyObject *swig_obj[1] ;
15136
15137 if (!args) SWIG_fail;
15138 swig_obj[0] = args;
15139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15140 if (!SWIG_IsOK(res1)) {
15141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15142 }
15143 arg1 = reinterpret_cast< wxImage * >(argp1);
15144 {
15145 PyThreadState* __tstate = wxPyBeginAllowThreads();
15146 result = (bool)(arg1)->Ok();
15147 wxPyEndAllowThreads(__tstate);
15148 if (PyErr_Occurred()) SWIG_fail;
15149 }
15150 {
15151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15152 }
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxImage *arg1 = (wxImage *) 0 ;
15162 int result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15172 }
15173 arg1 = reinterpret_cast< wxImage * >(argp1);
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (int)(arg1)->GetWidth();
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 resultobj = SWIG_From_int(static_cast< int >(result));
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *resultobj = 0;
15189 wxImage *arg1 = (wxImage *) 0 ;
15190 int result;
15191 void *argp1 = 0 ;
15192 int res1 = 0 ;
15193 PyObject *swig_obj[1] ;
15194
15195 if (!args) SWIG_fail;
15196 swig_obj[0] = args;
15197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15200 }
15201 arg1 = reinterpret_cast< wxImage * >(argp1);
15202 {
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 result = (int)(arg1)->GetHeight();
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 resultobj = SWIG_From_int(static_cast< int >(result));
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15216 PyObject *resultobj = 0;
15217 wxImage *arg1 = (wxImage *) 0 ;
15218 wxSize result;
15219 void *argp1 = 0 ;
15220 int res1 = 0 ;
15221 PyObject *swig_obj[1] ;
15222
15223 if (!args) SWIG_fail;
15224 swig_obj[0] = args;
15225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15226 if (!SWIG_IsOK(res1)) {
15227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15228 }
15229 arg1 = reinterpret_cast< wxImage * >(argp1);
15230 {
15231 PyThreadState* __tstate = wxPyBeginAllowThreads();
15232 result = wxImage_GetSize(arg1);
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15237 return resultobj;
15238 fail:
15239 return NULL;
15240 }
15241
15242
15243 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15244 PyObject *resultobj = 0;
15245 wxImage *arg1 = (wxImage *) 0 ;
15246 wxRect *arg2 = 0 ;
15247 SwigValueWrapper<wxImage > result;
15248 void *argp1 = 0 ;
15249 int res1 = 0 ;
15250 wxRect temp2 ;
15251 PyObject * obj0 = 0 ;
15252 PyObject * obj1 = 0 ;
15253 char * kwnames[] = {
15254 (char *) "self",(char *) "rect", NULL
15255 };
15256
15257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15259 if (!SWIG_IsOK(res1)) {
15260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15261 }
15262 arg1 = reinterpret_cast< wxImage * >(argp1);
15263 {
15264 arg2 = &temp2;
15265 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15266 }
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15281 PyObject *resultobj = 0;
15282 wxImage *arg1 = (wxImage *) 0 ;
15283 wxSize *arg2 = 0 ;
15284 wxPoint *arg3 = 0 ;
15285 int arg4 = (int) -1 ;
15286 int arg5 = (int) -1 ;
15287 int arg6 = (int) -1 ;
15288 SwigValueWrapper<wxImage > result;
15289 void *argp1 = 0 ;
15290 int res1 = 0 ;
15291 wxSize temp2 ;
15292 wxPoint temp3 ;
15293 int val4 ;
15294 int ecode4 = 0 ;
15295 int val5 ;
15296 int ecode5 = 0 ;
15297 int val6 ;
15298 int ecode6 = 0 ;
15299 PyObject * obj0 = 0 ;
15300 PyObject * obj1 = 0 ;
15301 PyObject * obj2 = 0 ;
15302 PyObject * obj3 = 0 ;
15303 PyObject * obj4 = 0 ;
15304 PyObject * obj5 = 0 ;
15305 char * kwnames[] = {
15306 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15307 };
15308
15309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15311 if (!SWIG_IsOK(res1)) {
15312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15313 }
15314 arg1 = reinterpret_cast< wxImage * >(argp1);
15315 {
15316 arg2 = &temp2;
15317 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15318 }
15319 {
15320 arg3 = &temp3;
15321 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15322 }
15323 if (obj3) {
15324 ecode4 = SWIG_AsVal_int(obj3, &val4);
15325 if (!SWIG_IsOK(ecode4)) {
15326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15327 }
15328 arg4 = static_cast< int >(val4);
15329 }
15330 if (obj4) {
15331 ecode5 = SWIG_AsVal_int(obj4, &val5);
15332 if (!SWIG_IsOK(ecode5)) {
15333 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15334 }
15335 arg5 = static_cast< int >(val5);
15336 }
15337 if (obj5) {
15338 ecode6 = SWIG_AsVal_int(obj5, &val6);
15339 if (!SWIG_IsOK(ecode6)) {
15340 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15341 }
15342 arg6 = static_cast< int >(val6);
15343 }
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15358 PyObject *resultobj = 0;
15359 wxImage *arg1 = (wxImage *) 0 ;
15360 SwigValueWrapper<wxImage > result;
15361 void *argp1 = 0 ;
15362 int res1 = 0 ;
15363 PyObject *swig_obj[1] ;
15364
15365 if (!args) SWIG_fail;
15366 swig_obj[0] = args;
15367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15368 if (!SWIG_IsOK(res1)) {
15369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15370 }
15371 arg1 = reinterpret_cast< wxImage * >(argp1);
15372 {
15373 PyThreadState* __tstate = wxPyBeginAllowThreads();
15374 result = (arg1)->Copy();
15375 wxPyEndAllowThreads(__tstate);
15376 if (PyErr_Occurred()) SWIG_fail;
15377 }
15378 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15379 return resultobj;
15380 fail:
15381 return NULL;
15382 }
15383
15384
15385 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15386 PyObject *resultobj = 0;
15387 wxImage *arg1 = (wxImage *) 0 ;
15388 wxImage *arg2 = 0 ;
15389 int arg3 ;
15390 int arg4 ;
15391 void *argp1 = 0 ;
15392 int res1 = 0 ;
15393 void *argp2 = 0 ;
15394 int res2 = 0 ;
15395 int val3 ;
15396 int ecode3 = 0 ;
15397 int val4 ;
15398 int ecode4 = 0 ;
15399 PyObject * obj0 = 0 ;
15400 PyObject * obj1 = 0 ;
15401 PyObject * obj2 = 0 ;
15402 PyObject * obj3 = 0 ;
15403 char * kwnames[] = {
15404 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15405 };
15406
15407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage * >(argp1);
15413 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15414 if (!SWIG_IsOK(res2)) {
15415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15416 }
15417 if (!argp2) {
15418 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15419 }
15420 arg2 = reinterpret_cast< wxImage * >(argp2);
15421 ecode3 = SWIG_AsVal_int(obj2, &val3);
15422 if (!SWIG_IsOK(ecode3)) {
15423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15424 }
15425 arg3 = static_cast< int >(val3);
15426 ecode4 = SWIG_AsVal_int(obj3, &val4);
15427 if (!SWIG_IsOK(ecode4)) {
15428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15429 }
15430 arg4 = static_cast< int >(val4);
15431 {
15432 PyThreadState* __tstate = wxPyBeginAllowThreads();
15433 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 resultobj = SWIG_Py_Void();
15438 return resultobj;
15439 fail:
15440 return NULL;
15441 }
15442
15443
15444 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15445 PyObject *resultobj = 0;
15446 wxImage *arg1 = (wxImage *) 0 ;
15447 PyObject *result = 0 ;
15448 void *argp1 = 0 ;
15449 int res1 = 0 ;
15450 PyObject *swig_obj[1] ;
15451
15452 if (!args) SWIG_fail;
15453 swig_obj[0] = args;
15454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15455 if (!SWIG_IsOK(res1)) {
15456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15457 }
15458 arg1 = reinterpret_cast< wxImage * >(argp1);
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 result = (PyObject *)wxImage_GetData(arg1);
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 resultobj = result;
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj = 0;
15474 wxImage *arg1 = (wxImage *) 0 ;
15475 buffer arg2 ;
15476 int arg3 ;
15477 void *argp1 = 0 ;
15478 int res1 = 0 ;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char * kwnames[] = {
15482 (char *) "self",(char *) "data", NULL
15483 };
15484
15485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15489 }
15490 arg1 = reinterpret_cast< wxImage * >(argp1);
15491 {
15492 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15493 }
15494 {
15495 PyThreadState* __tstate = wxPyBeginAllowThreads();
15496 wxImage_SetData(arg1,arg2,arg3);
15497 wxPyEndAllowThreads(__tstate);
15498 if (PyErr_Occurred()) SWIG_fail;
15499 }
15500 resultobj = SWIG_Py_Void();
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15508 PyObject *resultobj = 0;
15509 wxImage *arg1 = (wxImage *) 0 ;
15510 PyObject *result = 0 ;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 PyObject *swig_obj[1] ;
15514
15515 if (!args) SWIG_fail;
15516 swig_obj[0] = args;
15517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage * >(argp1);
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 resultobj = result;
15529 return resultobj;
15530 fail:
15531 return NULL;
15532 }
15533
15534
15535 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15536 PyObject *resultobj = 0;
15537 wxImage *arg1 = (wxImage *) 0 ;
15538 buffer arg2 ;
15539 int arg3 ;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 PyObject * obj0 = 0 ;
15543 PyObject * obj1 = 0 ;
15544 char * kwnames[] = {
15545 (char *) "self",(char *) "data", NULL
15546 };
15547
15548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15552 }
15553 arg1 = reinterpret_cast< wxImage * >(argp1);
15554 {
15555 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15556 }
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 wxImage_SetDataBuffer(arg1,arg2,arg3);
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 resultobj = SWIG_Py_Void();
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15571 PyObject *resultobj = 0;
15572 wxImage *arg1 = (wxImage *) 0 ;
15573 PyObject *result = 0 ;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject *swig_obj[1] ;
15577
15578 if (!args) SWIG_fail;
15579 swig_obj[0] = args;
15580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15581 if (!SWIG_IsOK(res1)) {
15582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15583 }
15584 arg1 = reinterpret_cast< wxImage * >(argp1);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (PyObject *)wxImage_GetAlphaData(arg1);
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = result;
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15599 PyObject *resultobj = 0;
15600 wxImage *arg1 = (wxImage *) 0 ;
15601 buffer arg2 ;
15602 int arg3 ;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 char * kwnames[] = {
15608 (char *) "self",(char *) "alpha", NULL
15609 };
15610
15611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15613 if (!SWIG_IsOK(res1)) {
15614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15615 }
15616 arg1 = reinterpret_cast< wxImage * >(argp1);
15617 {
15618 if (obj1 != Py_None) {
15619 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15620 }
15621 }
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 wxImage_SetAlphaData(arg1,arg2,arg3);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_Py_Void();
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *resultobj = 0;
15637 wxImage *arg1 = (wxImage *) 0 ;
15638 PyObject *result = 0 ;
15639 void *argp1 = 0 ;
15640 int res1 = 0 ;
15641 PyObject *swig_obj[1] ;
15642
15643 if (!args) SWIG_fail;
15644 swig_obj[0] = args;
15645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15646 if (!SWIG_IsOK(res1)) {
15647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15648 }
15649 arg1 = reinterpret_cast< wxImage * >(argp1);
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 resultobj = result;
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15664 PyObject *resultobj = 0;
15665 wxImage *arg1 = (wxImage *) 0 ;
15666 buffer arg2 ;
15667 int arg3 ;
15668 void *argp1 = 0 ;
15669 int res1 = 0 ;
15670 PyObject * obj0 = 0 ;
15671 PyObject * obj1 = 0 ;
15672 char * kwnames[] = {
15673 (char *) "self",(char *) "alpha", NULL
15674 };
15675
15676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15678 if (!SWIG_IsOK(res1)) {
15679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15680 }
15681 arg1 = reinterpret_cast< wxImage * >(argp1);
15682 {
15683 if (obj1 != Py_None) {
15684 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15685 }
15686 }
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15690 wxPyEndAllowThreads(__tstate);
15691 if (PyErr_Occurred()) SWIG_fail;
15692 }
15693 resultobj = SWIG_Py_Void();
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15701 PyObject *resultobj = 0;
15702 wxImage *arg1 = (wxImage *) 0 ;
15703 byte arg2 ;
15704 byte arg3 ;
15705 byte arg4 ;
15706 void *argp1 = 0 ;
15707 int res1 = 0 ;
15708 unsigned char val2 ;
15709 int ecode2 = 0 ;
15710 unsigned char val3 ;
15711 int ecode3 = 0 ;
15712 unsigned char val4 ;
15713 int ecode4 = 0 ;
15714 PyObject * obj0 = 0 ;
15715 PyObject * obj1 = 0 ;
15716 PyObject * obj2 = 0 ;
15717 PyObject * obj3 = 0 ;
15718 char * kwnames[] = {
15719 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15720 };
15721
15722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15724 if (!SWIG_IsOK(res1)) {
15725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15726 }
15727 arg1 = reinterpret_cast< wxImage * >(argp1);
15728 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15729 if (!SWIG_IsOK(ecode2)) {
15730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15731 }
15732 arg2 = static_cast< byte >(val2);
15733 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15734 if (!SWIG_IsOK(ecode3)) {
15735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15736 }
15737 arg3 = static_cast< byte >(val3);
15738 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15739 if (!SWIG_IsOK(ecode4)) {
15740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15741 }
15742 arg4 = static_cast< byte >(val4);
15743 {
15744 PyThreadState* __tstate = wxPyBeginAllowThreads();
15745 (arg1)->SetMaskColour(arg2,arg3,arg4);
15746 wxPyEndAllowThreads(__tstate);
15747 if (PyErr_Occurred()) SWIG_fail;
15748 }
15749 resultobj = SWIG_Py_Void();
15750 return resultobj;
15751 fail:
15752 return NULL;
15753 }
15754
15755
15756 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15757 PyObject *resultobj = 0;
15758 wxImage *arg1 = (wxImage *) 0 ;
15759 byte *arg2 = (byte *) 0 ;
15760 byte *arg3 = (byte *) 0 ;
15761 byte *arg4 = (byte *) 0 ;
15762 void *argp1 = 0 ;
15763 int res1 = 0 ;
15764 byte temp2 ;
15765 int res2 = SWIG_TMPOBJ ;
15766 byte temp3 ;
15767 int res3 = SWIG_TMPOBJ ;
15768 byte temp4 ;
15769 int res4 = SWIG_TMPOBJ ;
15770 PyObject *swig_obj[1] ;
15771
15772 arg2 = &temp2;
15773 arg3 = &temp3;
15774 arg4 = &temp4;
15775 if (!args) SWIG_fail;
15776 swig_obj[0] = args;
15777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15778 if (!SWIG_IsOK(res1)) {
15779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15780 }
15781 arg1 = reinterpret_cast< wxImage * >(argp1);
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15785 wxPyEndAllowThreads(__tstate);
15786 if (PyErr_Occurred()) SWIG_fail;
15787 }
15788 resultobj = SWIG_Py_Void();
15789 if (SWIG_IsTmpObj(res2)) {
15790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15791 } else {
15792 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15794 }
15795 if (SWIG_IsTmpObj(res3)) {
15796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15797 } else {
15798 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15800 }
15801 if (SWIG_IsTmpObj(res4)) {
15802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15803 } else {
15804 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15806 }
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15814 PyObject *resultobj = 0;
15815 wxImage *arg1 = (wxImage *) 0 ;
15816 byte result;
15817 void *argp1 = 0 ;
15818 int res1 = 0 ;
15819 PyObject *swig_obj[1] ;
15820
15821 if (!args) SWIG_fail;
15822 swig_obj[0] = args;
15823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15824 if (!SWIG_IsOK(res1)) {
15825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15826 }
15827 arg1 = reinterpret_cast< wxImage * >(argp1);
15828 {
15829 PyThreadState* __tstate = wxPyBeginAllowThreads();
15830 result = (byte)(arg1)->GetMaskRed();
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15842 PyObject *resultobj = 0;
15843 wxImage *arg1 = (wxImage *) 0 ;
15844 byte result;
15845 void *argp1 = 0 ;
15846 int res1 = 0 ;
15847 PyObject *swig_obj[1] ;
15848
15849 if (!args) SWIG_fail;
15850 swig_obj[0] = args;
15851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15852 if (!SWIG_IsOK(res1)) {
15853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15854 }
15855 arg1 = reinterpret_cast< wxImage * >(argp1);
15856 {
15857 PyThreadState* __tstate = wxPyBeginAllowThreads();
15858 result = (byte)(arg1)->GetMaskGreen();
15859 wxPyEndAllowThreads(__tstate);
15860 if (PyErr_Occurred()) SWIG_fail;
15861 }
15862 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15870 PyObject *resultobj = 0;
15871 wxImage *arg1 = (wxImage *) 0 ;
15872 byte result;
15873 void *argp1 = 0 ;
15874 int res1 = 0 ;
15875 PyObject *swig_obj[1] ;
15876
15877 if (!args) SWIG_fail;
15878 swig_obj[0] = args;
15879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15880 if (!SWIG_IsOK(res1)) {
15881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15882 }
15883 arg1 = reinterpret_cast< wxImage * >(argp1);
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 result = (byte)(arg1)->GetMaskBlue();
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15898 PyObject *resultobj = 0;
15899 wxImage *arg1 = (wxImage *) 0 ;
15900 bool arg2 = (bool) true ;
15901 void *argp1 = 0 ;
15902 int res1 = 0 ;
15903 bool val2 ;
15904 int ecode2 = 0 ;
15905 PyObject * obj0 = 0 ;
15906 PyObject * obj1 = 0 ;
15907 char * kwnames[] = {
15908 (char *) "self",(char *) "mask", NULL
15909 };
15910
15911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15913 if (!SWIG_IsOK(res1)) {
15914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15915 }
15916 arg1 = reinterpret_cast< wxImage * >(argp1);
15917 if (obj1) {
15918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15919 if (!SWIG_IsOK(ecode2)) {
15920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15921 }
15922 arg2 = static_cast< bool >(val2);
15923 }
15924 {
15925 PyThreadState* __tstate = wxPyBeginAllowThreads();
15926 (arg1)->SetMask(arg2);
15927 wxPyEndAllowThreads(__tstate);
15928 if (PyErr_Occurred()) SWIG_fail;
15929 }
15930 resultobj = SWIG_Py_Void();
15931 return resultobj;
15932 fail:
15933 return NULL;
15934 }
15935
15936
15937 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15938 PyObject *resultobj = 0;
15939 wxImage *arg1 = (wxImage *) 0 ;
15940 bool result;
15941 void *argp1 = 0 ;
15942 int res1 = 0 ;
15943 PyObject *swig_obj[1] ;
15944
15945 if (!args) SWIG_fail;
15946 swig_obj[0] = args;
15947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15948 if (!SWIG_IsOK(res1)) {
15949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15950 }
15951 arg1 = reinterpret_cast< wxImage * >(argp1);
15952 {
15953 PyThreadState* __tstate = wxPyBeginAllowThreads();
15954 result = (bool)(arg1)->HasMask();
15955 wxPyEndAllowThreads(__tstate);
15956 if (PyErr_Occurred()) SWIG_fail;
15957 }
15958 {
15959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15960 }
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj = 0;
15969 wxImage *arg1 = (wxImage *) 0 ;
15970 double arg2 ;
15971 wxPoint *arg3 = 0 ;
15972 bool arg4 = (bool) true ;
15973 wxPoint *arg5 = (wxPoint *) NULL ;
15974 SwigValueWrapper<wxImage > result;
15975 void *argp1 = 0 ;
15976 int res1 = 0 ;
15977 double val2 ;
15978 int ecode2 = 0 ;
15979 wxPoint temp3 ;
15980 bool val4 ;
15981 int ecode4 = 0 ;
15982 void *argp5 = 0 ;
15983 int res5 = 0 ;
15984 PyObject * obj0 = 0 ;
15985 PyObject * obj1 = 0 ;
15986 PyObject * obj2 = 0 ;
15987 PyObject * obj3 = 0 ;
15988 PyObject * obj4 = 0 ;
15989 char * kwnames[] = {
15990 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15991 };
15992
15993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15995 if (!SWIG_IsOK(res1)) {
15996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15997 }
15998 arg1 = reinterpret_cast< wxImage * >(argp1);
15999 ecode2 = SWIG_AsVal_double(obj1, &val2);
16000 if (!SWIG_IsOK(ecode2)) {
16001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16002 }
16003 arg2 = static_cast< double >(val2);
16004 {
16005 arg3 = &temp3;
16006 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16007 }
16008 if (obj3) {
16009 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16010 if (!SWIG_IsOK(ecode4)) {
16011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16012 }
16013 arg4 = static_cast< bool >(val4);
16014 }
16015 if (obj4) {
16016 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16017 if (!SWIG_IsOK(res5)) {
16018 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16019 }
16020 arg5 = reinterpret_cast< wxPoint * >(argp5);
16021 }
16022 {
16023 PyThreadState* __tstate = wxPyBeginAllowThreads();
16024 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj = 0;
16037 wxImage *arg1 = (wxImage *) 0 ;
16038 bool arg2 = (bool) true ;
16039 SwigValueWrapper<wxImage > result;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 bool val2 ;
16043 int ecode2 = 0 ;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 char * kwnames[] = {
16047 (char *) "self",(char *) "clockwise", NULL
16048 };
16049
16050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16052 if (!SWIG_IsOK(res1)) {
16053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16054 }
16055 arg1 = reinterpret_cast< wxImage * >(argp1);
16056 if (obj1) {
16057 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16058 if (!SWIG_IsOK(ecode2)) {
16059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16060 }
16061 arg2 = static_cast< bool >(val2);
16062 }
16063 {
16064 PyThreadState* __tstate = wxPyBeginAllowThreads();
16065 result = (arg1)->Rotate90(arg2);
16066 wxPyEndAllowThreads(__tstate);
16067 if (PyErr_Occurred()) SWIG_fail;
16068 }
16069 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16070 return resultobj;
16071 fail:
16072 return NULL;
16073 }
16074
16075
16076 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16077 PyObject *resultobj = 0;
16078 wxImage *arg1 = (wxImage *) 0 ;
16079 bool arg2 = (bool) true ;
16080 SwigValueWrapper<wxImage > result;
16081 void *argp1 = 0 ;
16082 int res1 = 0 ;
16083 bool val2 ;
16084 int ecode2 = 0 ;
16085 PyObject * obj0 = 0 ;
16086 PyObject * obj1 = 0 ;
16087 char * kwnames[] = {
16088 (char *) "self",(char *) "horizontally", NULL
16089 };
16090
16091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16093 if (!SWIG_IsOK(res1)) {
16094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16095 }
16096 arg1 = reinterpret_cast< wxImage * >(argp1);
16097 if (obj1) {
16098 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16099 if (!SWIG_IsOK(ecode2)) {
16100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16101 }
16102 arg2 = static_cast< bool >(val2);
16103 }
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (arg1)->Mirror(arg2);
16107 wxPyEndAllowThreads(__tstate);
16108 if (PyErr_Occurred()) SWIG_fail;
16109 }
16110 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16118 PyObject *resultobj = 0;
16119 wxImage *arg1 = (wxImage *) 0 ;
16120 byte arg2 ;
16121 byte arg3 ;
16122 byte arg4 ;
16123 byte arg5 ;
16124 byte arg6 ;
16125 byte arg7 ;
16126 void *argp1 = 0 ;
16127 int res1 = 0 ;
16128 unsigned char val2 ;
16129 int ecode2 = 0 ;
16130 unsigned char val3 ;
16131 int ecode3 = 0 ;
16132 unsigned char val4 ;
16133 int ecode4 = 0 ;
16134 unsigned char val5 ;
16135 int ecode5 = 0 ;
16136 unsigned char val6 ;
16137 int ecode6 = 0 ;
16138 unsigned char val7 ;
16139 int ecode7 = 0 ;
16140 PyObject * obj0 = 0 ;
16141 PyObject * obj1 = 0 ;
16142 PyObject * obj2 = 0 ;
16143 PyObject * obj3 = 0 ;
16144 PyObject * obj4 = 0 ;
16145 PyObject * obj5 = 0 ;
16146 PyObject * obj6 = 0 ;
16147 char * kwnames[] = {
16148 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16149 };
16150
16151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16153 if (!SWIG_IsOK(res1)) {
16154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16155 }
16156 arg1 = reinterpret_cast< wxImage * >(argp1);
16157 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16158 if (!SWIG_IsOK(ecode2)) {
16159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16160 }
16161 arg2 = static_cast< byte >(val2);
16162 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16163 if (!SWIG_IsOK(ecode3)) {
16164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16165 }
16166 arg3 = static_cast< byte >(val3);
16167 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16168 if (!SWIG_IsOK(ecode4)) {
16169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16170 }
16171 arg4 = static_cast< byte >(val4);
16172 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16173 if (!SWIG_IsOK(ecode5)) {
16174 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16175 }
16176 arg5 = static_cast< byte >(val5);
16177 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16178 if (!SWIG_IsOK(ecode6)) {
16179 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16180 }
16181 arg6 = static_cast< byte >(val6);
16182 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16183 if (!SWIG_IsOK(ecode7)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16185 }
16186 arg7 = static_cast< byte >(val7);
16187 {
16188 PyThreadState* __tstate = wxPyBeginAllowThreads();
16189 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16190 wxPyEndAllowThreads(__tstate);
16191 if (PyErr_Occurred()) SWIG_fail;
16192 }
16193 resultobj = SWIG_Py_Void();
16194 return resultobj;
16195 fail:
16196 return NULL;
16197 }
16198
16199
16200 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16201 PyObject *resultobj = 0;
16202 wxImage *arg1 = (wxImage *) 0 ;
16203 double arg2 = (double) 0.299 ;
16204 double arg3 = (double) 0.587 ;
16205 double arg4 = (double) 0.114 ;
16206 SwigValueWrapper<wxImage > result;
16207 void *argp1 = 0 ;
16208 int res1 = 0 ;
16209 double val2 ;
16210 int ecode2 = 0 ;
16211 double val3 ;
16212 int ecode3 = 0 ;
16213 double val4 ;
16214 int ecode4 = 0 ;
16215 PyObject * obj0 = 0 ;
16216 PyObject * obj1 = 0 ;
16217 PyObject * obj2 = 0 ;
16218 PyObject * obj3 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16227 }
16228 arg1 = reinterpret_cast< wxImage * >(argp1);
16229 if (obj1) {
16230 ecode2 = SWIG_AsVal_double(obj1, &val2);
16231 if (!SWIG_IsOK(ecode2)) {
16232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16233 }
16234 arg2 = static_cast< double >(val2);
16235 }
16236 if (obj2) {
16237 ecode3 = SWIG_AsVal_double(obj2, &val3);
16238 if (!SWIG_IsOK(ecode3)) {
16239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16240 }
16241 arg3 = static_cast< double >(val3);
16242 }
16243 if (obj3) {
16244 ecode4 = SWIG_AsVal_double(obj3, &val4);
16245 if (!SWIG_IsOK(ecode4)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16247 }
16248 arg4 = static_cast< double >(val4);
16249 }
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16264 PyObject *resultobj = 0;
16265 wxImage *arg1 = (wxImage *) 0 ;
16266 byte arg2 ;
16267 byte arg3 ;
16268 byte arg4 ;
16269 SwigValueWrapper<wxImage > result;
16270 void *argp1 = 0 ;
16271 int res1 = 0 ;
16272 unsigned char val2 ;
16273 int ecode2 = 0 ;
16274 unsigned char val3 ;
16275 int ecode3 = 0 ;
16276 unsigned char val4 ;
16277 int ecode4 = 0 ;
16278 PyObject * obj0 = 0 ;
16279 PyObject * obj1 = 0 ;
16280 PyObject * obj2 = 0 ;
16281 PyObject * obj3 = 0 ;
16282 char * kwnames[] = {
16283 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16284 };
16285
16286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16290 }
16291 arg1 = reinterpret_cast< wxImage * >(argp1);
16292 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16293 if (!SWIG_IsOK(ecode2)) {
16294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16295 }
16296 arg2 = static_cast< byte >(val2);
16297 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16298 if (!SWIG_IsOK(ecode3)) {
16299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16300 }
16301 arg3 = static_cast< byte >(val3);
16302 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16303 if (!SWIG_IsOK(ecode4)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16305 }
16306 arg4 = static_cast< byte >(val4);
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16321 PyObject *resultobj = 0;
16322 wxImage *arg1 = (wxImage *) 0 ;
16323 wxString *arg2 = 0 ;
16324 wxString *arg3 = 0 ;
16325 void *argp1 = 0 ;
16326 int res1 = 0 ;
16327 bool temp2 = false ;
16328 bool temp3 = false ;
16329 PyObject * obj0 = 0 ;
16330 PyObject * obj1 = 0 ;
16331 PyObject * obj2 = 0 ;
16332 char * kwnames[] = {
16333 (char *) "self",(char *) "name",(char *) "value", NULL
16334 };
16335
16336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16338 if (!SWIG_IsOK(res1)) {
16339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16340 }
16341 arg1 = reinterpret_cast< wxImage * >(argp1);
16342 {
16343 arg2 = wxString_in_helper(obj1);
16344 if (arg2 == NULL) SWIG_fail;
16345 temp2 = true;
16346 }
16347 {
16348 arg3 = wxString_in_helper(obj2);
16349 if (arg3 == NULL) SWIG_fail;
16350 temp3 = true;
16351 }
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 resultobj = SWIG_Py_Void();
16359 {
16360 if (temp2)
16361 delete arg2;
16362 }
16363 {
16364 if (temp3)
16365 delete arg3;
16366 }
16367 return resultobj;
16368 fail:
16369 {
16370 if (temp2)
16371 delete arg2;
16372 }
16373 {
16374 if (temp3)
16375 delete arg3;
16376 }
16377 return NULL;
16378 }
16379
16380
16381 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16382 PyObject *resultobj = 0;
16383 wxImage *arg1 = (wxImage *) 0 ;
16384 wxString *arg2 = 0 ;
16385 int arg3 ;
16386 void *argp1 = 0 ;
16387 int res1 = 0 ;
16388 bool temp2 = false ;
16389 int val3 ;
16390 int ecode3 = 0 ;
16391 PyObject * obj0 = 0 ;
16392 PyObject * obj1 = 0 ;
16393 PyObject * obj2 = 0 ;
16394 char * kwnames[] = {
16395 (char *) "self",(char *) "name",(char *) "value", NULL
16396 };
16397
16398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16400 if (!SWIG_IsOK(res1)) {
16401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16402 }
16403 arg1 = reinterpret_cast< wxImage * >(argp1);
16404 {
16405 arg2 = wxString_in_helper(obj1);
16406 if (arg2 == NULL) SWIG_fail;
16407 temp2 = true;
16408 }
16409 ecode3 = SWIG_AsVal_int(obj2, &val3);
16410 if (!SWIG_IsOK(ecode3)) {
16411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16412 }
16413 arg3 = static_cast< int >(val3);
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 (arg1)->SetOption((wxString const &)*arg2,arg3);
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 resultobj = SWIG_Py_Void();
16421 {
16422 if (temp2)
16423 delete arg2;
16424 }
16425 return resultobj;
16426 fail:
16427 {
16428 if (temp2)
16429 delete arg2;
16430 }
16431 return NULL;
16432 }
16433
16434
16435 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj = 0;
16437 wxImage *arg1 = (wxImage *) 0 ;
16438 wxString *arg2 = 0 ;
16439 wxString result;
16440 void *argp1 = 0 ;
16441 int res1 = 0 ;
16442 bool temp2 = false ;
16443 PyObject * obj0 = 0 ;
16444 PyObject * obj1 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "self",(char *) "name", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16453 }
16454 arg1 = reinterpret_cast< wxImage * >(argp1);
16455 {
16456 arg2 = wxString_in_helper(obj1);
16457 if (arg2 == NULL) SWIG_fail;
16458 temp2 = true;
16459 }
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16463 wxPyEndAllowThreads(__tstate);
16464 if (PyErr_Occurred()) SWIG_fail;
16465 }
16466 {
16467 #if wxUSE_UNICODE
16468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16469 #else
16470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16471 #endif
16472 }
16473 {
16474 if (temp2)
16475 delete arg2;
16476 }
16477 return resultobj;
16478 fail:
16479 {
16480 if (temp2)
16481 delete arg2;
16482 }
16483 return NULL;
16484 }
16485
16486
16487 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16488 PyObject *resultobj = 0;
16489 wxImage *arg1 = (wxImage *) 0 ;
16490 wxString *arg2 = 0 ;
16491 int result;
16492 void *argp1 = 0 ;
16493 int res1 = 0 ;
16494 bool temp2 = false ;
16495 PyObject * obj0 = 0 ;
16496 PyObject * obj1 = 0 ;
16497 char * kwnames[] = {
16498 (char *) "self",(char *) "name", NULL
16499 };
16500
16501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16503 if (!SWIG_IsOK(res1)) {
16504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16505 }
16506 arg1 = reinterpret_cast< wxImage * >(argp1);
16507 {
16508 arg2 = wxString_in_helper(obj1);
16509 if (arg2 == NULL) SWIG_fail;
16510 temp2 = true;
16511 }
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = SWIG_From_int(static_cast< int >(result));
16519 {
16520 if (temp2)
16521 delete arg2;
16522 }
16523 return resultobj;
16524 fail:
16525 {
16526 if (temp2)
16527 delete arg2;
16528 }
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxImage *arg1 = (wxImage *) 0 ;
16536 wxString *arg2 = 0 ;
16537 bool result;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 bool temp2 = false ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "self",(char *) "name", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImage * >(argp1);
16553 {
16554 arg2 = wxString_in_helper(obj1);
16555 if (arg2 == NULL) SWIG_fail;
16556 temp2 = true;
16557 }
16558 {
16559 PyThreadState* __tstate = wxPyBeginAllowThreads();
16560 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 {
16565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16566 }
16567 {
16568 if (temp2)
16569 delete arg2;
16570 }
16571 return resultobj;
16572 fail:
16573 {
16574 if (temp2)
16575 delete arg2;
16576 }
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj = 0;
16583 wxImage *arg1 = (wxImage *) 0 ;
16584 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16585 unsigned long result;
16586 void *argp1 = 0 ;
16587 int res1 = 0 ;
16588 unsigned long val2 ;
16589 int ecode2 = 0 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 char * kwnames[] = {
16593 (char *) "self",(char *) "stopafter", NULL
16594 };
16595
16596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16598 if (!SWIG_IsOK(res1)) {
16599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16600 }
16601 arg1 = reinterpret_cast< wxImage * >(argp1);
16602 if (obj1) {
16603 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16604 if (!SWIG_IsOK(ecode2)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16606 }
16607 arg2 = static_cast< unsigned long >(val2);
16608 }
16609 {
16610 PyThreadState* __tstate = wxPyBeginAllowThreads();
16611 result = (unsigned long)(arg1)->CountColours(arg2);
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16616 return resultobj;
16617 fail:
16618 return NULL;
16619 }
16620
16621
16622 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16623 PyObject *resultobj = 0;
16624 wxImage *arg1 = (wxImage *) 0 ;
16625 wxImageHistogram *arg2 = 0 ;
16626 unsigned long result;
16627 void *argp1 = 0 ;
16628 int res1 = 0 ;
16629 void *argp2 = 0 ;
16630 int res2 = 0 ;
16631 PyObject * obj0 = 0 ;
16632 PyObject * obj1 = 0 ;
16633 char * kwnames[] = {
16634 (char *) "self",(char *) "h", NULL
16635 };
16636
16637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16639 if (!SWIG_IsOK(res1)) {
16640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16641 }
16642 arg1 = reinterpret_cast< wxImage * >(argp1);
16643 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16644 if (!SWIG_IsOK(res2)) {
16645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16646 }
16647 if (!argp2) {
16648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16649 }
16650 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16651 {
16652 PyThreadState* __tstate = wxPyBeginAllowThreads();
16653 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16658 return resultobj;
16659 fail:
16660 return NULL;
16661 }
16662
16663
16664 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16665 PyObject *resultobj = 0;
16666 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16667 void *argp1 = 0 ;
16668 int res1 = 0 ;
16669 PyObject * obj0 = 0 ;
16670 char * kwnames[] = {
16671 (char *) "handler", NULL
16672 };
16673
16674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16676 if (!SWIG_IsOK(res1)) {
16677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16678 }
16679 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 wxImage::AddHandler(arg1);
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_Py_Void();
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj = 0;
16695 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 PyObject * obj0 = 0 ;
16699 char * kwnames[] = {
16700 (char *) "handler", NULL
16701 };
16702
16703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16707 }
16708 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 wxImage::InsertHandler(arg1);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxString *arg1 = 0 ;
16725 bool result;
16726 bool temp1 = false ;
16727 PyObject * obj0 = 0 ;
16728 char * kwnames[] = {
16729 (char *) "name", NULL
16730 };
16731
16732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16733 {
16734 arg1 = wxString_in_helper(obj0);
16735 if (arg1 == NULL) SWIG_fail;
16736 temp1 = true;
16737 }
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 {
16745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16746 }
16747 {
16748 if (temp1)
16749 delete arg1;
16750 }
16751 return resultobj;
16752 fail:
16753 {
16754 if (temp1)
16755 delete arg1;
16756 }
16757 return NULL;
16758 }
16759
16760
16761 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16762 PyObject *resultobj = 0;
16763 PyObject *result = 0 ;
16764
16765 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 result = (PyObject *)wxImage_GetHandlers();
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 resultobj = result;
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16780 PyObject *resultobj = 0;
16781 wxString result;
16782
16783 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16784 {
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 result = wxImage::GetImageExtWildcard();
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 {
16791 #if wxUSE_UNICODE
16792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16793 #else
16794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16795 #endif
16796 }
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj = 0;
16805 wxImage *arg1 = (wxImage *) 0 ;
16806 int arg2 = (int) -1 ;
16807 wxBitmap result;
16808 void *argp1 = 0 ;
16809 int res1 = 0 ;
16810 int val2 ;
16811 int ecode2 = 0 ;
16812 PyObject * obj0 = 0 ;
16813 PyObject * obj1 = 0 ;
16814 char * kwnames[] = {
16815 (char *) "self",(char *) "depth", NULL
16816 };
16817
16818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16822 }
16823 arg1 = reinterpret_cast< wxImage * >(argp1);
16824 if (obj1) {
16825 ecode2 = SWIG_AsVal_int(obj1, &val2);
16826 if (!SWIG_IsOK(ecode2)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16828 }
16829 arg2 = static_cast< int >(val2);
16830 }
16831 {
16832 if (!wxPyCheckForApp()) SWIG_fail;
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 result = wxImage_ConvertToBitmap(arg1,arg2);
16835 wxPyEndAllowThreads(__tstate);
16836 if (PyErr_Occurred()) SWIG_fail;
16837 }
16838 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj = 0;
16847 wxImage *arg1 = (wxImage *) 0 ;
16848 byte arg2 ;
16849 byte arg3 ;
16850 byte arg4 ;
16851 wxBitmap result;
16852 void *argp1 = 0 ;
16853 int res1 = 0 ;
16854 unsigned char val2 ;
16855 int ecode2 = 0 ;
16856 unsigned char val3 ;
16857 int ecode3 = 0 ;
16858 unsigned char val4 ;
16859 int ecode4 = 0 ;
16860 PyObject * obj0 = 0 ;
16861 PyObject * obj1 = 0 ;
16862 PyObject * obj2 = 0 ;
16863 PyObject * obj3 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16870 if (!SWIG_IsOK(res1)) {
16871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16872 }
16873 arg1 = reinterpret_cast< wxImage * >(argp1);
16874 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16875 if (!SWIG_IsOK(ecode2)) {
16876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16877 }
16878 arg2 = static_cast< byte >(val2);
16879 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16880 if (!SWIG_IsOK(ecode3)) {
16881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16882 }
16883 arg3 = static_cast< byte >(val3);
16884 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16885 if (!SWIG_IsOK(ecode4)) {
16886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16887 }
16888 arg4 = static_cast< byte >(val4);
16889 {
16890 if (!wxPyCheckForApp()) SWIG_fail;
16891 PyThreadState* __tstate = wxPyBeginAllowThreads();
16892 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16897 return resultobj;
16898 fail:
16899 return NULL;
16900 }
16901
16902
16903 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16904 PyObject *resultobj = 0;
16905 wxImage *arg1 = (wxImage *) 0 ;
16906 double arg2 ;
16907 void *argp1 = 0 ;
16908 int res1 = 0 ;
16909 double val2 ;
16910 int ecode2 = 0 ;
16911 PyObject * obj0 = 0 ;
16912 PyObject * obj1 = 0 ;
16913 char * kwnames[] = {
16914 (char *) "self",(char *) "angle", NULL
16915 };
16916
16917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16919 if (!SWIG_IsOK(res1)) {
16920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16921 }
16922 arg1 = reinterpret_cast< wxImage * >(argp1);
16923 ecode2 = SWIG_AsVal_double(obj1, &val2);
16924 if (!SWIG_IsOK(ecode2)) {
16925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16926 }
16927 arg2 = static_cast< double >(val2);
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 (arg1)->RotateHue(arg2);
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 resultobj = SWIG_Py_Void();
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj = 0;
16943 wxImage_RGBValue arg1 ;
16944 wxImage_HSVValue result;
16945 void *argp1 ;
16946 int res1 = 0 ;
16947 PyObject * obj0 = 0 ;
16948 char * kwnames[] = {
16949 (char *) "rgb", NULL
16950 };
16951
16952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16953 {
16954 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16955 if (!SWIG_IsOK(res1)) {
16956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16957 }
16958 if (!argp1) {
16959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16960 } else {
16961 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16962 arg1 = *temp;
16963 if (SWIG_IsNewObj(res1)) delete temp;
16964 }
16965 }
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 result = wxImage::RGBtoHSV(arg1);
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj = 0;
16981 wxImage_HSVValue arg1 ;
16982 wxImage_RGBValue result;
16983 void *argp1 ;
16984 int res1 = 0 ;
16985 PyObject * obj0 = 0 ;
16986 char * kwnames[] = {
16987 (char *) "hsv", NULL
16988 };
16989
16990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16991 {
16992 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16993 if (!SWIG_IsOK(res1)) {
16994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16995 }
16996 if (!argp1) {
16997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16998 } else {
16999 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17000 arg1 = *temp;
17001 if (SWIG_IsNewObj(res1)) delete temp;
17002 }
17003 }
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = wxImage::HSVtoRGB(arg1);
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17018 PyObject *obj;
17019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17020 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17021 return SWIG_Py_Void();
17022 }
17023
17024 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17025 return SWIG_Python_InitShadowInstance(args);
17026 }
17027
17028 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 int arg1 ;
17031 int arg2 ;
17032 buffer arg3 ;
17033 int arg4 ;
17034 buffer arg5 = (buffer) NULL ;
17035 int arg6 = (int) 0 ;
17036 wxImage *result = 0 ;
17037 int val1 ;
17038 int ecode1 = 0 ;
17039 int val2 ;
17040 int ecode2 = 0 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 PyObject * obj2 = 0 ;
17044 PyObject * obj3 = 0 ;
17045 char * kwnames[] = {
17046 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17047 };
17048
17049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17050 ecode1 = SWIG_AsVal_int(obj0, &val1);
17051 if (!SWIG_IsOK(ecode1)) {
17052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17053 }
17054 arg1 = static_cast< int >(val1);
17055 ecode2 = SWIG_AsVal_int(obj1, &val2);
17056 if (!SWIG_IsOK(ecode2)) {
17057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17058 }
17059 arg2 = static_cast< int >(val2);
17060 {
17061 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
17062 }
17063 if (obj3) {
17064 {
17065 if (obj3 != Py_None) {
17066 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &arg6) == -1) SWIG_fail;
17067 }
17068 }
17069 }
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 {
17077 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17078 }
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 SWIGINTERN int NullImage_set(PyObject *) {
17086 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17087 return 1;
17088 }
17089
17090
17091 SWIGINTERN PyObject *NullImage_get(void) {
17092 PyObject *pyobj = 0;
17093
17094 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17095 return pyobj;
17096 }
17097
17098
17099 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17100 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17101 return 1;
17102 }
17103
17104
17105 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17106 PyObject *pyobj = 0;
17107
17108 {
17109 #if wxUSE_UNICODE
17110 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17111 #else
17112 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17113 #endif
17114 }
17115 return pyobj;
17116 }
17117
17118
17119 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17120 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17121 return 1;
17122 }
17123
17124
17125 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17126 PyObject *pyobj = 0;
17127
17128 {
17129 #if wxUSE_UNICODE
17130 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17131 #else
17132 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17133 #endif
17134 }
17135 return pyobj;
17136 }
17137
17138
17139 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17140 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17141 return 1;
17142 }
17143
17144
17145 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17146 PyObject *pyobj = 0;
17147
17148 {
17149 #if wxUSE_UNICODE
17150 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17151 #else
17152 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17153 #endif
17154 }
17155 return pyobj;
17156 }
17157
17158
17159 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17160 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17161 return 1;
17162 }
17163
17164
17165 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17166 PyObject *pyobj = 0;
17167
17168 {
17169 #if wxUSE_UNICODE
17170 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17171 #else
17172 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17173 #endif
17174 }
17175 return pyobj;
17176 }
17177
17178
17179 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17180 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17181 return 1;
17182 }
17183
17184
17185 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17186 PyObject *pyobj = 0;
17187
17188 {
17189 #if wxUSE_UNICODE
17190 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17191 #else
17192 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17193 #endif
17194 }
17195 return pyobj;
17196 }
17197
17198
17199 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17200 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17201 return 1;
17202 }
17203
17204
17205 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17206 PyObject *pyobj = 0;
17207
17208 {
17209 #if wxUSE_UNICODE
17210 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17211 #else
17212 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17213 #endif
17214 }
17215 return pyobj;
17216 }
17217
17218
17219 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17220 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17221 return 1;
17222 }
17223
17224
17225 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17226 PyObject *pyobj = 0;
17227
17228 {
17229 #if wxUSE_UNICODE
17230 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17231 #else
17232 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17233 #endif
17234 }
17235 return pyobj;
17236 }
17237
17238
17239 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17240 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17241 return 1;
17242 }
17243
17244
17245 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17246 PyObject *pyobj = 0;
17247
17248 {
17249 #if wxUSE_UNICODE
17250 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17251 #else
17252 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17253 #endif
17254 }
17255 return pyobj;
17256 }
17257
17258
17259 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17260 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17261 return 1;
17262 }
17263
17264
17265 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17266 PyObject *pyobj = 0;
17267
17268 {
17269 #if wxUSE_UNICODE
17270 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17271 #else
17272 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17273 #endif
17274 }
17275 return pyobj;
17276 }
17277
17278
17279 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17280 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17281 return 1;
17282 }
17283
17284
17285 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17286 PyObject *pyobj = 0;
17287
17288 {
17289 #if wxUSE_UNICODE
17290 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17291 #else
17292 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17293 #endif
17294 }
17295 return pyobj;
17296 }
17297
17298
17299 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17300 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17301 return 1;
17302 }
17303
17304
17305 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17306 PyObject *pyobj = 0;
17307
17308 {
17309 #if wxUSE_UNICODE
17310 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17311 #else
17312 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17313 #endif
17314 }
17315 return pyobj;
17316 }
17317
17318
17319 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17320 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17321 return 1;
17322 }
17323
17324
17325 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17326 PyObject *pyobj = 0;
17327
17328 {
17329 #if wxUSE_UNICODE
17330 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17331 #else
17332 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17333 #endif
17334 }
17335 return pyobj;
17336 }
17337
17338
17339 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17340 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17341 return 1;
17342 }
17343
17344
17345 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17346 PyObject *pyobj = 0;
17347
17348 {
17349 #if wxUSE_UNICODE
17350 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17351 #else
17352 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17353 #endif
17354 }
17355 return pyobj;
17356 }
17357
17358
17359 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17360 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17361 return 1;
17362 }
17363
17364
17365 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17366 PyObject *pyobj = 0;
17367
17368 {
17369 #if wxUSE_UNICODE
17370 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17371 #else
17372 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17373 #endif
17374 }
17375 return pyobj;
17376 }
17377
17378
17379 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17380 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17381 return 1;
17382 }
17383
17384
17385 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17386 PyObject *pyobj = 0;
17387
17388 {
17389 #if wxUSE_UNICODE
17390 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17391 #else
17392 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17393 #endif
17394 }
17395 return pyobj;
17396 }
17397
17398
17399 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17400 PyObject *resultobj = 0;
17401 wxBMPHandler *result = 0 ;
17402
17403 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (wxBMPHandler *)new wxBMPHandler();
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17418 PyObject *obj;
17419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17420 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17421 return SWIG_Py_Void();
17422 }
17423
17424 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17425 return SWIG_Python_InitShadowInstance(args);
17426 }
17427
17428 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17429 PyObject *resultobj = 0;
17430 wxICOHandler *result = 0 ;
17431
17432 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17433 {
17434 PyThreadState* __tstate = wxPyBeginAllowThreads();
17435 result = (wxICOHandler *)new wxICOHandler();
17436 wxPyEndAllowThreads(__tstate);
17437 if (PyErr_Occurred()) SWIG_fail;
17438 }
17439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17440 return resultobj;
17441 fail:
17442 return NULL;
17443 }
17444
17445
17446 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17447 PyObject *obj;
17448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17449 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17450 return SWIG_Py_Void();
17451 }
17452
17453 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17454 return SWIG_Python_InitShadowInstance(args);
17455 }
17456
17457 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 PyObject *resultobj = 0;
17459 wxCURHandler *result = 0 ;
17460
17461 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17462 {
17463 PyThreadState* __tstate = wxPyBeginAllowThreads();
17464 result = (wxCURHandler *)new wxCURHandler();
17465 wxPyEndAllowThreads(__tstate);
17466 if (PyErr_Occurred()) SWIG_fail;
17467 }
17468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17469 return resultobj;
17470 fail:
17471 return NULL;
17472 }
17473
17474
17475 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *obj;
17477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17478 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17479 return SWIG_Py_Void();
17480 }
17481
17482 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17483 return SWIG_Python_InitShadowInstance(args);
17484 }
17485
17486 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *resultobj = 0;
17488 wxANIHandler *result = 0 ;
17489
17490 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 result = (wxANIHandler *)new wxANIHandler();
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17498 return resultobj;
17499 fail:
17500 return NULL;
17501 }
17502
17503
17504 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17505 PyObject *obj;
17506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17507 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17508 return SWIG_Py_Void();
17509 }
17510
17511 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17512 return SWIG_Python_InitShadowInstance(args);
17513 }
17514
17515 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 PyObject *resultobj = 0;
17517 wxPNGHandler *result = 0 ;
17518
17519 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17520 {
17521 PyThreadState* __tstate = wxPyBeginAllowThreads();
17522 result = (wxPNGHandler *)new wxPNGHandler();
17523 wxPyEndAllowThreads(__tstate);
17524 if (PyErr_Occurred()) SWIG_fail;
17525 }
17526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17527 return resultobj;
17528 fail:
17529 return NULL;
17530 }
17531
17532
17533 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17534 PyObject *obj;
17535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17536 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17537 return SWIG_Py_Void();
17538 }
17539
17540 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17541 return SWIG_Python_InitShadowInstance(args);
17542 }
17543
17544 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 PyObject *resultobj = 0;
17546 wxGIFHandler *result = 0 ;
17547
17548 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17549 {
17550 PyThreadState* __tstate = wxPyBeginAllowThreads();
17551 result = (wxGIFHandler *)new wxGIFHandler();
17552 wxPyEndAllowThreads(__tstate);
17553 if (PyErr_Occurred()) SWIG_fail;
17554 }
17555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17556 return resultobj;
17557 fail:
17558 return NULL;
17559 }
17560
17561
17562 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17563 PyObject *obj;
17564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17565 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17566 return SWIG_Py_Void();
17567 }
17568
17569 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17570 return SWIG_Python_InitShadowInstance(args);
17571 }
17572
17573 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *resultobj = 0;
17575 wxPCXHandler *result = 0 ;
17576
17577 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = (wxPCXHandler *)new wxPCXHandler();
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *obj;
17593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17594 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17595 return SWIG_Py_Void();
17596 }
17597
17598 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 return SWIG_Python_InitShadowInstance(args);
17600 }
17601
17602 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 PyObject *resultobj = 0;
17604 wxJPEGHandler *result = 0 ;
17605
17606 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (wxJPEGHandler *)new wxJPEGHandler();
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *obj;
17622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17623 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17624 return SWIG_Py_Void();
17625 }
17626
17627 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17628 return SWIG_Python_InitShadowInstance(args);
17629 }
17630
17631 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 PyObject *resultobj = 0;
17633 wxPNMHandler *result = 0 ;
17634
17635 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (wxPNMHandler *)new wxPNMHandler();
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *obj;
17651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17652 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17653 return SWIG_Py_Void();
17654 }
17655
17656 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17657 return SWIG_Python_InitShadowInstance(args);
17658 }
17659
17660 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17661 PyObject *resultobj = 0;
17662 wxXPMHandler *result = 0 ;
17663
17664 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (wxXPMHandler *)new wxXPMHandler();
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17679 PyObject *obj;
17680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17681 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17682 return SWIG_Py_Void();
17683 }
17684
17685 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17686 return SWIG_Python_InitShadowInstance(args);
17687 }
17688
17689 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 PyObject *resultobj = 0;
17691 wxTIFFHandler *result = 0 ;
17692
17693 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 result = (wxTIFFHandler *)new wxTIFFHandler();
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17701 return resultobj;
17702 fail:
17703 return NULL;
17704 }
17705
17706
17707 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *obj;
17709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17710 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17711 return SWIG_Py_Void();
17712 }
17713
17714 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17715 return SWIG_Python_InitShadowInstance(args);
17716 }
17717
17718 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj = 0;
17720 wxImage *arg1 = 0 ;
17721 wxImage *arg2 = 0 ;
17722 int arg3 = (int) 236 ;
17723 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17724 bool result;
17725 void *argp1 = 0 ;
17726 int res1 = 0 ;
17727 void *argp2 = 0 ;
17728 int res2 = 0 ;
17729 int val3 ;
17730 int ecode3 = 0 ;
17731 int val4 ;
17732 int ecode4 = 0 ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 PyObject * obj2 = 0 ;
17736 PyObject * obj3 = 0 ;
17737 char * kwnames[] = {
17738 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17739 };
17740
17741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17742 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17743 if (!SWIG_IsOK(res1)) {
17744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17745 }
17746 if (!argp1) {
17747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17748 }
17749 arg1 = reinterpret_cast< wxImage * >(argp1);
17750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17751 if (!SWIG_IsOK(res2)) {
17752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17753 }
17754 if (!argp2) {
17755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17756 }
17757 arg2 = reinterpret_cast< wxImage * >(argp2);
17758 if (obj2) {
17759 ecode3 = SWIG_AsVal_int(obj2, &val3);
17760 if (!SWIG_IsOK(ecode3)) {
17761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17762 }
17763 arg3 = static_cast< int >(val3);
17764 }
17765 if (obj3) {
17766 ecode4 = SWIG_AsVal_int(obj3, &val4);
17767 if (!SWIG_IsOK(ecode4)) {
17768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17769 }
17770 arg4 = static_cast< int >(val4);
17771 }
17772 {
17773 PyThreadState* __tstate = wxPyBeginAllowThreads();
17774 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 {
17779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17780 }
17781 return resultobj;
17782 fail:
17783 return NULL;
17784 }
17785
17786
17787 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17788 PyObject *obj;
17789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17790 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17791 return SWIG_Py_Void();
17792 }
17793
17794 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17795 PyObject *resultobj = 0;
17796 wxEvtHandler *result = 0 ;
17797
17798 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17799 {
17800 PyThreadState* __tstate = wxPyBeginAllowThreads();
17801 result = (wxEvtHandler *)new wxEvtHandler();
17802 wxPyEndAllowThreads(__tstate);
17803 if (PyErr_Occurred()) SWIG_fail;
17804 }
17805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17813 PyObject *resultobj = 0;
17814 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17815 wxEvtHandler *result = 0 ;
17816 void *argp1 = 0 ;
17817 int res1 = 0 ;
17818 PyObject *swig_obj[1] ;
17819
17820 if (!args) SWIG_fail;
17821 swig_obj[0] = args;
17822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17823 if (!SWIG_IsOK(res1)) {
17824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17825 }
17826 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 {
17834 resultobj = wxPyMake_wxObject(result, 0);
17835 }
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17845 wxEvtHandler *result = 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17855 }
17856 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 {
17864 resultobj = wxPyMake_wxObject(result, 0);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj = 0;
17874 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17875 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 void *argp2 = 0 ;
17879 int res2 = 0 ;
17880 PyObject * obj0 = 0 ;
17881 PyObject * obj1 = 0 ;
17882 char * kwnames[] = {
17883 (char *) "self",(char *) "handler", NULL
17884 };
17885
17886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17890 }
17891 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17893 if (!SWIG_IsOK(res2)) {
17894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17895 }
17896 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 (arg1)->SetNextHandler(arg2);
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17913 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 void *argp2 = 0 ;
17917 int res2 = 0 ;
17918 PyObject * obj0 = 0 ;
17919 PyObject * obj1 = 0 ;
17920 char * kwnames[] = {
17921 (char *) "self",(char *) "handler", NULL
17922 };
17923
17924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17926 if (!SWIG_IsOK(res1)) {
17927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17928 }
17929 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17931 if (!SWIG_IsOK(res2)) {
17932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17933 }
17934 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 (arg1)->SetPreviousHandler(arg2);
17938 wxPyEndAllowThreads(__tstate);
17939 if (PyErr_Occurred()) SWIG_fail;
17940 }
17941 resultobj = SWIG_Py_Void();
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17949 PyObject *resultobj = 0;
17950 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17951 bool result;
17952 void *argp1 = 0 ;
17953 int res1 = 0 ;
17954 PyObject *swig_obj[1] ;
17955
17956 if (!args) SWIG_fail;
17957 swig_obj[0] = args;
17958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17959 if (!SWIG_IsOK(res1)) {
17960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17961 }
17962 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (bool)(arg1)->GetEvtHandlerEnabled();
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 {
17970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17971 }
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj = 0;
17980 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17981 bool arg2 ;
17982 void *argp1 = 0 ;
17983 int res1 = 0 ;
17984 bool val2 ;
17985 int ecode2 = 0 ;
17986 PyObject * obj0 = 0 ;
17987 PyObject * obj1 = 0 ;
17988 char * kwnames[] = {
17989 (char *) "self",(char *) "enabled", NULL
17990 };
17991
17992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17994 if (!SWIG_IsOK(res1)) {
17995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17996 }
17997 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17999 if (!SWIG_IsOK(ecode2)) {
18000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18001 }
18002 arg2 = static_cast< bool >(val2);
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 (arg1)->SetEvtHandlerEnabled(arg2);
18006 wxPyEndAllowThreads(__tstate);
18007 if (PyErr_Occurred()) SWIG_fail;
18008 }
18009 resultobj = SWIG_Py_Void();
18010 return resultobj;
18011 fail:
18012 return NULL;
18013 }
18014
18015
18016 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18017 PyObject *resultobj = 0;
18018 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18019 wxEvent *arg2 = 0 ;
18020 bool result;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 void *argp2 = 0 ;
18024 int res2 = 0 ;
18025 PyObject * obj0 = 0 ;
18026 PyObject * obj1 = 0 ;
18027 char * kwnames[] = {
18028 (char *) "self",(char *) "event", NULL
18029 };
18030
18031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18035 }
18036 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18037 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18038 if (!SWIG_IsOK(res2)) {
18039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18040 }
18041 if (!argp2) {
18042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18043 }
18044 arg2 = reinterpret_cast< wxEvent * >(argp2);
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (bool)(arg1)->ProcessEvent(*arg2);
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj = 0;
18062 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18063 wxEvent *arg2 = 0 ;
18064 void *argp1 = 0 ;
18065 int res1 = 0 ;
18066 void *argp2 = 0 ;
18067 int res2 = 0 ;
18068 PyObject * obj0 = 0 ;
18069 PyObject * obj1 = 0 ;
18070 char * kwnames[] = {
18071 (char *) "self",(char *) "event", NULL
18072 };
18073
18074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18076 if (!SWIG_IsOK(res1)) {
18077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18078 }
18079 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18081 if (!SWIG_IsOK(res2)) {
18082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18083 }
18084 if (!argp2) {
18085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18086 }
18087 arg2 = reinterpret_cast< wxEvent * >(argp2);
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 (arg1)->AddPendingEvent(*arg2);
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 resultobj = SWIG_Py_Void();
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18102 PyObject *resultobj = 0;
18103 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18104 void *argp1 = 0 ;
18105 int res1 = 0 ;
18106 PyObject *swig_obj[1] ;
18107
18108 if (!args) SWIG_fail;
18109 swig_obj[0] = args;
18110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18113 }
18114 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 (arg1)->ProcessPendingEvents();
18118 wxPyEndAllowThreads(__tstate);
18119 if (PyErr_Occurred()) SWIG_fail;
18120 }
18121 resultobj = SWIG_Py_Void();
18122 return resultobj;
18123 fail:
18124 return NULL;
18125 }
18126
18127
18128 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj = 0;
18130 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18131 int arg2 ;
18132 int arg3 ;
18133 int arg4 ;
18134 PyObject *arg5 = (PyObject *) 0 ;
18135 void *argp1 = 0 ;
18136 int res1 = 0 ;
18137 int val2 ;
18138 int ecode2 = 0 ;
18139 int val3 ;
18140 int ecode3 = 0 ;
18141 int val4 ;
18142 int ecode4 = 0 ;
18143 PyObject * obj0 = 0 ;
18144 PyObject * obj1 = 0 ;
18145 PyObject * obj2 = 0 ;
18146 PyObject * obj3 = 0 ;
18147 PyObject * obj4 = 0 ;
18148 char * kwnames[] = {
18149 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18150 };
18151
18152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18154 if (!SWIG_IsOK(res1)) {
18155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18156 }
18157 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18158 ecode2 = SWIG_AsVal_int(obj1, &val2);
18159 if (!SWIG_IsOK(ecode2)) {
18160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18161 }
18162 arg2 = static_cast< int >(val2);
18163 ecode3 = SWIG_AsVal_int(obj2, &val3);
18164 if (!SWIG_IsOK(ecode3)) {
18165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18166 }
18167 arg3 = static_cast< int >(val3);
18168 ecode4 = SWIG_AsVal_int(obj3, &val4);
18169 if (!SWIG_IsOK(ecode4)) {
18170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18171 }
18172 arg4 = static_cast< int >(val4);
18173 arg5 = obj4;
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 resultobj = SWIG_Py_Void();
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj = 0;
18189 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18190 int arg2 ;
18191 int arg3 = (int) -1 ;
18192 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18193 bool result;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 int val2 ;
18197 int ecode2 = 0 ;
18198 int val3 ;
18199 int ecode3 = 0 ;
18200 int val4 ;
18201 int ecode4 = 0 ;
18202 PyObject * obj0 = 0 ;
18203 PyObject * obj1 = 0 ;
18204 PyObject * obj2 = 0 ;
18205 PyObject * obj3 = 0 ;
18206 char * kwnames[] = {
18207 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18208 };
18209
18210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18212 if (!SWIG_IsOK(res1)) {
18213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18214 }
18215 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18216 ecode2 = SWIG_AsVal_int(obj1, &val2);
18217 if (!SWIG_IsOK(ecode2)) {
18218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18219 }
18220 arg2 = static_cast< int >(val2);
18221 if (obj2) {
18222 ecode3 = SWIG_AsVal_int(obj2, &val3);
18223 if (!SWIG_IsOK(ecode3)) {
18224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18225 }
18226 arg3 = static_cast< int >(val3);
18227 }
18228 if (obj3) {
18229 ecode4 = SWIG_AsVal_int(obj3, &val4);
18230 if (!SWIG_IsOK(ecode4)) {
18231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18232 }
18233 arg4 = static_cast< wxEventType >(val4);
18234 }
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 {
18242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18243 }
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj = 0;
18252 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18253 PyObject *arg2 = (PyObject *) 0 ;
18254 bool arg3 = (bool) true ;
18255 void *argp1 = 0 ;
18256 int res1 = 0 ;
18257 bool val3 ;
18258 int ecode3 = 0 ;
18259 PyObject * obj0 = 0 ;
18260 PyObject * obj1 = 0 ;
18261 PyObject * obj2 = 0 ;
18262 char * kwnames[] = {
18263 (char *) "self",(char *) "_self",(char *) "incref", NULL
18264 };
18265
18266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18268 if (!SWIG_IsOK(res1)) {
18269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18270 }
18271 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18272 arg2 = obj1;
18273 if (obj2) {
18274 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18275 if (!SWIG_IsOK(ecode3)) {
18276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18277 }
18278 arg3 = static_cast< bool >(val3);
18279 }
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 resultobj = SWIG_Py_Void();
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18294 PyObject *obj;
18295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18296 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18297 return SWIG_Py_Void();
18298 }
18299
18300 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18301 return SWIG_Python_InitShadowInstance(args);
18302 }
18303
18304 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18305 PyObject *resultobj = 0;
18306 wxEventType result;
18307
18308 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (wxEventType)wxNewEventType();
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 resultobj = SWIG_From_int(static_cast< int >(result));
18316 return resultobj;
18317 fail:
18318 return NULL;
18319 }
18320
18321
18322 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18323 PyObject *resultobj = 0;
18324 wxEvent *arg1 = (wxEvent *) 0 ;
18325 void *argp1 = 0 ;
18326 int res1 = 0 ;
18327 PyObject *swig_obj[1] ;
18328
18329 if (!args) SWIG_fail;
18330 swig_obj[0] = args;
18331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18332 if (!SWIG_IsOK(res1)) {
18333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18334 }
18335 arg1 = reinterpret_cast< wxEvent * >(argp1);
18336 {
18337 PyThreadState* __tstate = wxPyBeginAllowThreads();
18338 delete arg1;
18339
18340 wxPyEndAllowThreads(__tstate);
18341 if (PyErr_Occurred()) SWIG_fail;
18342 }
18343 resultobj = SWIG_Py_Void();
18344 return resultobj;
18345 fail:
18346 return NULL;
18347 }
18348
18349
18350 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18351 PyObject *resultobj = 0;
18352 wxEvent *arg1 = (wxEvent *) 0 ;
18353 wxEventType arg2 ;
18354 void *argp1 = 0 ;
18355 int res1 = 0 ;
18356 int val2 ;
18357 int ecode2 = 0 ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 char * kwnames[] = {
18361 (char *) "self",(char *) "typ", NULL
18362 };
18363
18364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18366 if (!SWIG_IsOK(res1)) {
18367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18368 }
18369 arg1 = reinterpret_cast< wxEvent * >(argp1);
18370 ecode2 = SWIG_AsVal_int(obj1, &val2);
18371 if (!SWIG_IsOK(ecode2)) {
18372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18373 }
18374 arg2 = static_cast< wxEventType >(val2);
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 (arg1)->SetEventType(arg2);
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 resultobj = SWIG_Py_Void();
18382 return resultobj;
18383 fail:
18384 return NULL;
18385 }
18386
18387
18388 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18389 PyObject *resultobj = 0;
18390 wxEvent *arg1 = (wxEvent *) 0 ;
18391 wxEventType result;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 PyObject *swig_obj[1] ;
18395
18396 if (!args) SWIG_fail;
18397 swig_obj[0] = args;
18398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18399 if (!SWIG_IsOK(res1)) {
18400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18401 }
18402 arg1 = reinterpret_cast< wxEvent * >(argp1);
18403 {
18404 PyThreadState* __tstate = wxPyBeginAllowThreads();
18405 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 resultobj = SWIG_From_int(static_cast< int >(result));
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18417 PyObject *resultobj = 0;
18418 wxEvent *arg1 = (wxEvent *) 0 ;
18419 wxObject *result = 0 ;
18420 void *argp1 = 0 ;
18421 int res1 = 0 ;
18422 PyObject *swig_obj[1] ;
18423
18424 if (!args) SWIG_fail;
18425 swig_obj[0] = args;
18426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18427 if (!SWIG_IsOK(res1)) {
18428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18429 }
18430 arg1 = reinterpret_cast< wxEvent * >(argp1);
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = wxPyMake_wxObject(result, (bool)0);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj = 0;
18448 wxEvent *arg1 = (wxEvent *) 0 ;
18449 wxObject *arg2 = (wxObject *) 0 ;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 void *argp2 = 0 ;
18453 int res2 = 0 ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 char * kwnames[] = {
18457 (char *) "self",(char *) "obj", NULL
18458 };
18459
18460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18462 if (!SWIG_IsOK(res1)) {
18463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18464 }
18465 arg1 = reinterpret_cast< wxEvent * >(argp1);
18466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18467 if (!SWIG_IsOK(res2)) {
18468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18469 }
18470 arg2 = reinterpret_cast< wxObject * >(argp2);
18471 {
18472 PyThreadState* __tstate = wxPyBeginAllowThreads();
18473 (arg1)->SetEventObject(arg2);
18474 wxPyEndAllowThreads(__tstate);
18475 if (PyErr_Occurred()) SWIG_fail;
18476 }
18477 resultobj = SWIG_Py_Void();
18478 return resultobj;
18479 fail:
18480 return NULL;
18481 }
18482
18483
18484 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18485 PyObject *resultobj = 0;
18486 wxEvent *arg1 = (wxEvent *) 0 ;
18487 long result;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 PyObject *swig_obj[1] ;
18491
18492 if (!args) SWIG_fail;
18493 swig_obj[0] = args;
18494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18497 }
18498 arg1 = reinterpret_cast< wxEvent * >(argp1);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_From_long(static_cast< long >(result));
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 long arg2 = (long) 0 ;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 long val2 ;
18519 int ecode2 = 0 ;
18520 PyObject * obj0 = 0 ;
18521 PyObject * obj1 = 0 ;
18522 char * kwnames[] = {
18523 (char *) "self",(char *) "ts", NULL
18524 };
18525
18526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18528 if (!SWIG_IsOK(res1)) {
18529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18530 }
18531 arg1 = reinterpret_cast< wxEvent * >(argp1);
18532 if (obj1) {
18533 ecode2 = SWIG_AsVal_long(obj1, &val2);
18534 if (!SWIG_IsOK(ecode2)) {
18535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18536 }
18537 arg2 = static_cast< long >(val2);
18538 }
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 (arg1)->SetTimestamp(arg2);
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 resultobj = SWIG_Py_Void();
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18553 PyObject *resultobj = 0;
18554 wxEvent *arg1 = (wxEvent *) 0 ;
18555 int result;
18556 void *argp1 = 0 ;
18557 int res1 = 0 ;
18558 PyObject *swig_obj[1] ;
18559
18560 if (!args) SWIG_fail;
18561 swig_obj[0] = args;
18562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18563 if (!SWIG_IsOK(res1)) {
18564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18565 }
18566 arg1 = reinterpret_cast< wxEvent * >(argp1);
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (int)((wxEvent const *)arg1)->GetId();
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 resultobj = SWIG_From_int(static_cast< int >(result));
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj = 0;
18582 wxEvent *arg1 = (wxEvent *) 0 ;
18583 int arg2 ;
18584 void *argp1 = 0 ;
18585 int res1 = 0 ;
18586 int val2 ;
18587 int ecode2 = 0 ;
18588 PyObject * obj0 = 0 ;
18589 PyObject * obj1 = 0 ;
18590 char * kwnames[] = {
18591 (char *) "self",(char *) "Id", NULL
18592 };
18593
18594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18596 if (!SWIG_IsOK(res1)) {
18597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18598 }
18599 arg1 = reinterpret_cast< wxEvent * >(argp1);
18600 ecode2 = SWIG_AsVal_int(obj1, &val2);
18601 if (!SWIG_IsOK(ecode2)) {
18602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18603 }
18604 arg2 = static_cast< int >(val2);
18605 {
18606 PyThreadState* __tstate = wxPyBeginAllowThreads();
18607 (arg1)->SetId(arg2);
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 resultobj = SWIG_Py_Void();
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18619 PyObject *resultobj = 0;
18620 wxEvent *arg1 = (wxEvent *) 0 ;
18621 bool result;
18622 void *argp1 = 0 ;
18623 int res1 = 0 ;
18624 PyObject *swig_obj[1] ;
18625
18626 if (!args) SWIG_fail;
18627 swig_obj[0] = args;
18628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18629 if (!SWIG_IsOK(res1)) {
18630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18631 }
18632 arg1 = reinterpret_cast< wxEvent * >(argp1);
18633 {
18634 PyThreadState* __tstate = wxPyBeginAllowThreads();
18635 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18636 wxPyEndAllowThreads(__tstate);
18637 if (PyErr_Occurred()) SWIG_fail;
18638 }
18639 {
18640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18641 }
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18649 PyObject *resultobj = 0;
18650 wxEvent *arg1 = (wxEvent *) 0 ;
18651 bool arg2 = (bool) true ;
18652 void *argp1 = 0 ;
18653 int res1 = 0 ;
18654 bool val2 ;
18655 int ecode2 = 0 ;
18656 PyObject * obj0 = 0 ;
18657 PyObject * obj1 = 0 ;
18658 char * kwnames[] = {
18659 (char *) "self",(char *) "skip", NULL
18660 };
18661
18662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18664 if (!SWIG_IsOK(res1)) {
18665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18666 }
18667 arg1 = reinterpret_cast< wxEvent * >(argp1);
18668 if (obj1) {
18669 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18670 if (!SWIG_IsOK(ecode2)) {
18671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18672 }
18673 arg2 = static_cast< bool >(val2);
18674 }
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 (arg1)->Skip(arg2);
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 resultobj = SWIG_Py_Void();
18682 return resultobj;
18683 fail:
18684 return NULL;
18685 }
18686
18687
18688 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18689 PyObject *resultobj = 0;
18690 wxEvent *arg1 = (wxEvent *) 0 ;
18691 bool result;
18692 void *argp1 = 0 ;
18693 int res1 = 0 ;
18694 PyObject *swig_obj[1] ;
18695
18696 if (!args) SWIG_fail;
18697 swig_obj[0] = args;
18698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18699 if (!SWIG_IsOK(res1)) {
18700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18701 }
18702 arg1 = reinterpret_cast< wxEvent * >(argp1);
18703 {
18704 PyThreadState* __tstate = wxPyBeginAllowThreads();
18705 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18706 wxPyEndAllowThreads(__tstate);
18707 if (PyErr_Occurred()) SWIG_fail;
18708 }
18709 {
18710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18711 }
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18719 PyObject *resultobj = 0;
18720 wxEvent *arg1 = (wxEvent *) 0 ;
18721 bool result;
18722 void *argp1 = 0 ;
18723 int res1 = 0 ;
18724 PyObject *swig_obj[1] ;
18725
18726 if (!args) SWIG_fail;
18727 swig_obj[0] = args;
18728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18729 if (!SWIG_IsOK(res1)) {
18730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18731 }
18732 arg1 = reinterpret_cast< wxEvent * >(argp1);
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 {
18740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18749 PyObject *resultobj = 0;
18750 wxEvent *arg1 = (wxEvent *) 0 ;
18751 int result;
18752 void *argp1 = 0 ;
18753 int res1 = 0 ;
18754 PyObject *swig_obj[1] ;
18755
18756 if (!args) SWIG_fail;
18757 swig_obj[0] = args;
18758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18759 if (!SWIG_IsOK(res1)) {
18760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18761 }
18762 arg1 = reinterpret_cast< wxEvent * >(argp1);
18763 {
18764 PyThreadState* __tstate = wxPyBeginAllowThreads();
18765 result = (int)(arg1)->StopPropagation();
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 resultobj = SWIG_From_int(static_cast< int >(result));
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj = 0;
18778 wxEvent *arg1 = (wxEvent *) 0 ;
18779 int arg2 ;
18780 void *argp1 = 0 ;
18781 int res1 = 0 ;
18782 int val2 ;
18783 int ecode2 = 0 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "self",(char *) "propagationLevel", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18794 }
18795 arg1 = reinterpret_cast< wxEvent * >(argp1);
18796 ecode2 = SWIG_AsVal_int(obj1, &val2);
18797 if (!SWIG_IsOK(ecode2)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18799 }
18800 arg2 = static_cast< int >(val2);
18801 {
18802 PyThreadState* __tstate = wxPyBeginAllowThreads();
18803 (arg1)->ResumePropagation(arg2);
18804 wxPyEndAllowThreads(__tstate);
18805 if (PyErr_Occurred()) SWIG_fail;
18806 }
18807 resultobj = SWIG_Py_Void();
18808 return resultobj;
18809 fail:
18810 return NULL;
18811 }
18812
18813
18814 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18815 PyObject *resultobj = 0;
18816 wxEvent *arg1 = (wxEvent *) 0 ;
18817 wxEvent *result = 0 ;
18818 void *argp1 = 0 ;
18819 int res1 = 0 ;
18820 PyObject *swig_obj[1] ;
18821
18822 if (!args) SWIG_fail;
18823 swig_obj[0] = args;
18824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18825 if (!SWIG_IsOK(res1)) {
18826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18827 }
18828 arg1 = reinterpret_cast< wxEvent * >(argp1);
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 result = (wxEvent *)(arg1)->Clone();
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18843 PyObject *obj;
18844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18845 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18846 return SWIG_Py_Void();
18847 }
18848
18849 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18850 PyObject *resultobj = 0;
18851 wxEvent *arg1 = 0 ;
18852 wxPropagationDisabler *result = 0 ;
18853 void *argp1 = 0 ;
18854 int res1 = 0 ;
18855 PyObject * obj0 = 0 ;
18856 char * kwnames[] = {
18857 (char *) "event", NULL
18858 };
18859
18860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18861 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18862 if (!SWIG_IsOK(res1)) {
18863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18864 }
18865 if (!argp1) {
18866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18867 }
18868 arg1 = reinterpret_cast< wxEvent * >(argp1);
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18883 PyObject *resultobj = 0;
18884 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18885 void *argp1 = 0 ;
18886 int res1 = 0 ;
18887 PyObject *swig_obj[1] ;
18888
18889 if (!args) SWIG_fail;
18890 swig_obj[0] = args;
18891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18892 if (!SWIG_IsOK(res1)) {
18893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18894 }
18895 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18896 {
18897 PyThreadState* __tstate = wxPyBeginAllowThreads();
18898 delete arg1;
18899
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_Py_Void();
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18911 PyObject *obj;
18912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18913 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18914 return SWIG_Py_Void();
18915 }
18916
18917 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18918 return SWIG_Python_InitShadowInstance(args);
18919 }
18920
18921 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj = 0;
18923 wxEvent *arg1 = 0 ;
18924 wxPropagateOnce *result = 0 ;
18925 void *argp1 = 0 ;
18926 int res1 = 0 ;
18927 PyObject * obj0 = 0 ;
18928 char * kwnames[] = {
18929 (char *) "event", NULL
18930 };
18931
18932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18933 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18934 if (!SWIG_IsOK(res1)) {
18935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18936 }
18937 if (!argp1) {
18938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18939 }
18940 arg1 = reinterpret_cast< wxEvent * >(argp1);
18941 {
18942 PyThreadState* __tstate = wxPyBeginAllowThreads();
18943 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18955 PyObject *resultobj = 0;
18956 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18957 void *argp1 = 0 ;
18958 int res1 = 0 ;
18959 PyObject *swig_obj[1] ;
18960
18961 if (!args) SWIG_fail;
18962 swig_obj[0] = args;
18963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18964 if (!SWIG_IsOK(res1)) {
18965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18966 }
18967 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 delete arg1;
18971
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 resultobj = SWIG_Py_Void();
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18983 PyObject *obj;
18984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18985 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18986 return SWIG_Py_Void();
18987 }
18988
18989 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18990 return SWIG_Python_InitShadowInstance(args);
18991 }
18992
18993 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj = 0;
18995 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18996 int arg2 = (int) 0 ;
18997 wxCommandEvent *result = 0 ;
18998 int val1 ;
18999 int ecode1 = 0 ;
19000 int val2 ;
19001 int ecode2 = 0 ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "commandType",(char *) "winid", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19009 if (obj0) {
19010 ecode1 = SWIG_AsVal_int(obj0, &val1);
19011 if (!SWIG_IsOK(ecode1)) {
19012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19013 }
19014 arg1 = static_cast< wxEventType >(val1);
19015 }
19016 if (obj1) {
19017 ecode2 = SWIG_AsVal_int(obj1, &val2);
19018 if (!SWIG_IsOK(ecode2)) {
19019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19020 }
19021 arg2 = static_cast< int >(val2);
19022 }
19023 {
19024 PyThreadState* __tstate = wxPyBeginAllowThreads();
19025 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19026 wxPyEndAllowThreads(__tstate);
19027 if (PyErr_Occurred()) SWIG_fail;
19028 }
19029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19037 PyObject *resultobj = 0;
19038 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19039 int result;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 PyObject *swig_obj[1] ;
19043
19044 if (!args) SWIG_fail;
19045 swig_obj[0] = args;
19046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19049 }
19050 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19051 {
19052 PyThreadState* __tstate = wxPyBeginAllowThreads();
19053 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 resultobj = SWIG_From_int(static_cast< int >(result));
19058 return resultobj;
19059 fail:
19060 return NULL;
19061 }
19062
19063
19064 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19065 PyObject *resultobj = 0;
19066 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19067 wxString *arg2 = 0 ;
19068 void *argp1 = 0 ;
19069 int res1 = 0 ;
19070 bool temp2 = false ;
19071 PyObject * obj0 = 0 ;
19072 PyObject * obj1 = 0 ;
19073 char * kwnames[] = {
19074 (char *) "self",(char *) "s", NULL
19075 };
19076
19077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19079 if (!SWIG_IsOK(res1)) {
19080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19081 }
19082 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19083 {
19084 arg2 = wxString_in_helper(obj1);
19085 if (arg2 == NULL) SWIG_fail;
19086 temp2 = true;
19087 }
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 (arg1)->SetString((wxString const &)*arg2);
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 resultobj = SWIG_Py_Void();
19095 {
19096 if (temp2)
19097 delete arg2;
19098 }
19099 return resultobj;
19100 fail:
19101 {
19102 if (temp2)
19103 delete arg2;
19104 }
19105 return NULL;
19106 }
19107
19108
19109 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19110 PyObject *resultobj = 0;
19111 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19112 wxString result;
19113 void *argp1 = 0 ;
19114 int res1 = 0 ;
19115 PyObject *swig_obj[1] ;
19116
19117 if (!args) SWIG_fail;
19118 swig_obj[0] = args;
19119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19120 if (!SWIG_IsOK(res1)) {
19121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19122 }
19123 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19124 {
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 result = ((wxCommandEvent const *)arg1)->GetString();
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 {
19131 #if wxUSE_UNICODE
19132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19133 #else
19134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19135 #endif
19136 }
19137 return resultobj;
19138 fail:
19139 return NULL;
19140 }
19141
19142
19143 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19144 PyObject *resultobj = 0;
19145 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19146 bool result;
19147 void *argp1 = 0 ;
19148 int res1 = 0 ;
19149 PyObject *swig_obj[1] ;
19150
19151 if (!args) SWIG_fail;
19152 swig_obj[0] = args;
19153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19154 if (!SWIG_IsOK(res1)) {
19155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19156 }
19157 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19158 {
19159 PyThreadState* __tstate = wxPyBeginAllowThreads();
19160 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19161 wxPyEndAllowThreads(__tstate);
19162 if (PyErr_Occurred()) SWIG_fail;
19163 }
19164 {
19165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19166 }
19167 return resultobj;
19168 fail:
19169 return NULL;
19170 }
19171
19172
19173 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19174 PyObject *resultobj = 0;
19175 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19176 bool result;
19177 void *argp1 = 0 ;
19178 int res1 = 0 ;
19179 PyObject *swig_obj[1] ;
19180
19181 if (!args) SWIG_fail;
19182 swig_obj[0] = args;
19183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19184 if (!SWIG_IsOK(res1)) {
19185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19186 }
19187 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19188 {
19189 PyThreadState* __tstate = wxPyBeginAllowThreads();
19190 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 {
19195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19196 }
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19204 PyObject *resultobj = 0;
19205 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19206 long arg2 ;
19207 void *argp1 = 0 ;
19208 int res1 = 0 ;
19209 long val2 ;
19210 int ecode2 = 0 ;
19211 PyObject * obj0 = 0 ;
19212 PyObject * obj1 = 0 ;
19213 char * kwnames[] = {
19214 (char *) "self",(char *) "extraLong", NULL
19215 };
19216
19217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19219 if (!SWIG_IsOK(res1)) {
19220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19221 }
19222 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19223 ecode2 = SWIG_AsVal_long(obj1, &val2);
19224 if (!SWIG_IsOK(ecode2)) {
19225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19226 }
19227 arg2 = static_cast< long >(val2);
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 (arg1)->SetExtraLong(arg2);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_Py_Void();
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19242 PyObject *resultobj = 0;
19243 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19244 long result;
19245 void *argp1 = 0 ;
19246 int res1 = 0 ;
19247 PyObject *swig_obj[1] ;
19248
19249 if (!args) SWIG_fail;
19250 swig_obj[0] = args;
19251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19252 if (!SWIG_IsOK(res1)) {
19253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19254 }
19255 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 resultobj = SWIG_From_long(static_cast< long >(result));
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19270 PyObject *resultobj = 0;
19271 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19272 int arg2 ;
19273 void *argp1 = 0 ;
19274 int res1 = 0 ;
19275 int val2 ;
19276 int ecode2 = 0 ;
19277 PyObject * obj0 = 0 ;
19278 PyObject * obj1 = 0 ;
19279 char * kwnames[] = {
19280 (char *) "self",(char *) "i", NULL
19281 };
19282
19283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19285 if (!SWIG_IsOK(res1)) {
19286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19287 }
19288 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19289 ecode2 = SWIG_AsVal_int(obj1, &val2);
19290 if (!SWIG_IsOK(ecode2)) {
19291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19292 }
19293 arg2 = static_cast< int >(val2);
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 (arg1)->SetInt(arg2);
19297 wxPyEndAllowThreads(__tstate);
19298 if (PyErr_Occurred()) SWIG_fail;
19299 }
19300 resultobj = SWIG_Py_Void();
19301 return resultobj;
19302 fail:
19303 return NULL;
19304 }
19305
19306
19307 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19308 PyObject *resultobj = 0;
19309 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19310 int result;
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_wxCommandEvent, 0 | 0 );
19318 if (!SWIG_IsOK(res1)) {
19319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19320 }
19321 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19322 {
19323 PyThreadState* __tstate = wxPyBeginAllowThreads();
19324 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 resultobj = SWIG_From_int(static_cast< int >(result));
19329 return resultobj;
19330 fail:
19331 return NULL;
19332 }
19333
19334
19335 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19336 PyObject *resultobj = 0;
19337 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19338 PyObject *result = 0 ;
19339 void *argp1 = 0 ;
19340 int res1 = 0 ;
19341 PyObject *swig_obj[1] ;
19342
19343 if (!args) SWIG_fail;
19344 swig_obj[0] = args;
19345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19346 if (!SWIG_IsOK(res1)) {
19347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19348 }
19349 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 resultobj = result;
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19364 PyObject *resultobj = 0;
19365 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19366 PyObject *arg2 = (PyObject *) 0 ;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 PyObject * obj0 = 0 ;
19370 PyObject * obj1 = 0 ;
19371 char * kwnames[] = {
19372 (char *) "self",(char *) "clientData", NULL
19373 };
19374
19375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19377 if (!SWIG_IsOK(res1)) {
19378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19379 }
19380 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19381 arg2 = obj1;
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 wxCommandEvent_SetClientData(arg1,arg2);
19385 wxPyEndAllowThreads(__tstate);
19386 if (PyErr_Occurred()) SWIG_fail;
19387 }
19388 resultobj = SWIG_Py_Void();
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19396 PyObject *resultobj = 0;
19397 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19398 wxEvent *result = 0 ;
19399 void *argp1 = 0 ;
19400 int res1 = 0 ;
19401 PyObject *swig_obj[1] ;
19402
19403 if (!args) SWIG_fail;
19404 swig_obj[0] = args;
19405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19406 if (!SWIG_IsOK(res1)) {
19407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19408 }
19409 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19410 {
19411 PyThreadState* __tstate = wxPyBeginAllowThreads();
19412 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19424 PyObject *obj;
19425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19426 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19427 return SWIG_Py_Void();
19428 }
19429
19430 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19431 return SWIG_Python_InitShadowInstance(args);
19432 }
19433
19434 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj = 0;
19436 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19437 int arg2 = (int) 0 ;
19438 wxNotifyEvent *result = 0 ;
19439 int val1 ;
19440 int ecode1 = 0 ;
19441 int val2 ;
19442 int ecode2 = 0 ;
19443 PyObject * obj0 = 0 ;
19444 PyObject * obj1 = 0 ;
19445 char * kwnames[] = {
19446 (char *) "commandType",(char *) "winid", NULL
19447 };
19448
19449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19450 if (obj0) {
19451 ecode1 = SWIG_AsVal_int(obj0, &val1);
19452 if (!SWIG_IsOK(ecode1)) {
19453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19454 }
19455 arg1 = static_cast< wxEventType >(val1);
19456 }
19457 if (obj1) {
19458 ecode2 = SWIG_AsVal_int(obj1, &val2);
19459 if (!SWIG_IsOK(ecode2)) {
19460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19461 }
19462 arg2 = static_cast< int >(val2);
19463 }
19464 {
19465 PyThreadState* __tstate = wxPyBeginAllowThreads();
19466 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19478 PyObject *resultobj = 0;
19479 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 PyObject *swig_obj[1] ;
19483
19484 if (!args) SWIG_fail;
19485 swig_obj[0] = args;
19486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19489 }
19490 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 (arg1)->Veto();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = SWIG_Py_Void();
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *resultobj = 0;
19506 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19507 void *argp1 = 0 ;
19508 int res1 = 0 ;
19509 PyObject *swig_obj[1] ;
19510
19511 if (!args) SWIG_fail;
19512 swig_obj[0] = args;
19513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19514 if (!SWIG_IsOK(res1)) {
19515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19516 }
19517 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 (arg1)->Allow();
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 resultobj = SWIG_Py_Void();
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19532 PyObject *resultobj = 0;
19533 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19534 bool result;
19535 void *argp1 = 0 ;
19536 int res1 = 0 ;
19537 PyObject *swig_obj[1] ;
19538
19539 if (!args) SWIG_fail;
19540 swig_obj[0] = args;
19541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19542 if (!SWIG_IsOK(res1)) {
19543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19544 }
19545 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (bool)(arg1)->IsAllowed();
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 {
19553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19554 }
19555 return resultobj;
19556 fail:
19557 return NULL;
19558 }
19559
19560
19561 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19562 PyObject *obj;
19563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19564 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19565 return SWIG_Py_Void();
19566 }
19567
19568 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19569 return SWIG_Python_InitShadowInstance(args);
19570 }
19571
19572 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19573 PyObject *resultobj = 0;
19574 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19575 int arg2 = (int) 0 ;
19576 int arg3 = (int) 0 ;
19577 int arg4 = (int) 0 ;
19578 wxScrollEvent *result = 0 ;
19579 int val1 ;
19580 int ecode1 = 0 ;
19581 int val2 ;
19582 int ecode2 = 0 ;
19583 int val3 ;
19584 int ecode3 = 0 ;
19585 int val4 ;
19586 int ecode4 = 0 ;
19587 PyObject * obj0 = 0 ;
19588 PyObject * obj1 = 0 ;
19589 PyObject * obj2 = 0 ;
19590 PyObject * obj3 = 0 ;
19591 char * kwnames[] = {
19592 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19593 };
19594
19595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19596 if (obj0) {
19597 ecode1 = SWIG_AsVal_int(obj0, &val1);
19598 if (!SWIG_IsOK(ecode1)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19600 }
19601 arg1 = static_cast< wxEventType >(val1);
19602 }
19603 if (obj1) {
19604 ecode2 = SWIG_AsVal_int(obj1, &val2);
19605 if (!SWIG_IsOK(ecode2)) {
19606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19607 }
19608 arg2 = static_cast< int >(val2);
19609 }
19610 if (obj2) {
19611 ecode3 = SWIG_AsVal_int(obj2, &val3);
19612 if (!SWIG_IsOK(ecode3)) {
19613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19614 }
19615 arg3 = static_cast< int >(val3);
19616 }
19617 if (obj3) {
19618 ecode4 = SWIG_AsVal_int(obj3, &val4);
19619 if (!SWIG_IsOK(ecode4)) {
19620 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19621 }
19622 arg4 = static_cast< int >(val4);
19623 }
19624 {
19625 PyThreadState* __tstate = wxPyBeginAllowThreads();
19626 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19627 wxPyEndAllowThreads(__tstate);
19628 if (PyErr_Occurred()) SWIG_fail;
19629 }
19630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19638 PyObject *resultobj = 0;
19639 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19640 int result;
19641 void *argp1 = 0 ;
19642 int res1 = 0 ;
19643 PyObject *swig_obj[1] ;
19644
19645 if (!args) SWIG_fail;
19646 swig_obj[0] = args;
19647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19648 if (!SWIG_IsOK(res1)) {
19649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19650 }
19651 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 resultobj = SWIG_From_int(static_cast< int >(result));
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19666 PyObject *resultobj = 0;
19667 wxScrollEvent *arg1 = (wxScrollEvent *) 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_wxScrollEvent, 0 | 0 );
19676 if (!SWIG_IsOK(res1)) {
19677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19678 }
19679 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
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_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19694 PyObject *resultobj = 0;
19695 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19696 int arg2 ;
19697 void *argp1 = 0 ;
19698 int res1 = 0 ;
19699 int val2 ;
19700 int ecode2 = 0 ;
19701 PyObject * obj0 = 0 ;
19702 PyObject * obj1 = 0 ;
19703 char * kwnames[] = {
19704 (char *) "self",(char *) "orient", NULL
19705 };
19706
19707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19711 }
19712 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19713 ecode2 = SWIG_AsVal_int(obj1, &val2);
19714 if (!SWIG_IsOK(ecode2)) {
19715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19716 }
19717 arg2 = static_cast< int >(val2);
19718 {
19719 PyThreadState* __tstate = wxPyBeginAllowThreads();
19720 (arg1)->SetOrientation(arg2);
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 resultobj = SWIG_Py_Void();
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj = 0;
19733 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19734 int arg2 ;
19735 void *argp1 = 0 ;
19736 int res1 = 0 ;
19737 int val2 ;
19738 int ecode2 = 0 ;
19739 PyObject * obj0 = 0 ;
19740 PyObject * obj1 = 0 ;
19741 char * kwnames[] = {
19742 (char *) "self",(char *) "pos", NULL
19743 };
19744
19745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19747 if (!SWIG_IsOK(res1)) {
19748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19749 }
19750 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19751 ecode2 = SWIG_AsVal_int(obj1, &val2);
19752 if (!SWIG_IsOK(ecode2)) {
19753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19754 }
19755 arg2 = static_cast< int >(val2);
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 (arg1)->SetPosition(arg2);
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 resultobj = SWIG_Py_Void();
19763 return resultobj;
19764 fail:
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19770 PyObject *obj;
19771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19772 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19773 return SWIG_Py_Void();
19774 }
19775
19776 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19777 return SWIG_Python_InitShadowInstance(args);
19778 }
19779
19780 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19781 PyObject *resultobj = 0;
19782 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19783 int arg2 = (int) 0 ;
19784 int arg3 = (int) 0 ;
19785 wxScrollWinEvent *result = 0 ;
19786 int val1 ;
19787 int ecode1 = 0 ;
19788 int val2 ;
19789 int ecode2 = 0 ;
19790 int val3 ;
19791 int ecode3 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 PyObject * obj2 = 0 ;
19795 char * kwnames[] = {
19796 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19797 };
19798
19799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19800 if (obj0) {
19801 ecode1 = SWIG_AsVal_int(obj0, &val1);
19802 if (!SWIG_IsOK(ecode1)) {
19803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19804 }
19805 arg1 = static_cast< wxEventType >(val1);
19806 }
19807 if (obj1) {
19808 ecode2 = SWIG_AsVal_int(obj1, &val2);
19809 if (!SWIG_IsOK(ecode2)) {
19810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19811 }
19812 arg2 = static_cast< int >(val2);
19813 }
19814 if (obj2) {
19815 ecode3 = SWIG_AsVal_int(obj2, &val3);
19816 if (!SWIG_IsOK(ecode3)) {
19817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19818 }
19819 arg3 = static_cast< int >(val3);
19820 }
19821 {
19822 PyThreadState* __tstate = wxPyBeginAllowThreads();
19823 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19824 wxPyEndAllowThreads(__tstate);
19825 if (PyErr_Occurred()) SWIG_fail;
19826 }
19827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19828 return resultobj;
19829 fail:
19830 return NULL;
19831 }
19832
19833
19834 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19835 PyObject *resultobj = 0;
19836 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19837 int result;
19838 void *argp1 = 0 ;
19839 int res1 = 0 ;
19840 PyObject *swig_obj[1] ;
19841
19842 if (!args) SWIG_fail;
19843 swig_obj[0] = args;
19844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19845 if (!SWIG_IsOK(res1)) {
19846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19847 }
19848 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19849 {
19850 PyThreadState* __tstate = wxPyBeginAllowThreads();
19851 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19852 wxPyEndAllowThreads(__tstate);
19853 if (PyErr_Occurred()) SWIG_fail;
19854 }
19855 resultobj = SWIG_From_int(static_cast< int >(result));
19856 return resultobj;
19857 fail:
19858 return NULL;
19859 }
19860
19861
19862 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19863 PyObject *resultobj = 0;
19864 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19865 int result;
19866 void *argp1 = 0 ;
19867 int res1 = 0 ;
19868 PyObject *swig_obj[1] ;
19869
19870 if (!args) SWIG_fail;
19871 swig_obj[0] = args;
19872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19873 if (!SWIG_IsOK(res1)) {
19874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19875 }
19876 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19877 {
19878 PyThreadState* __tstate = wxPyBeginAllowThreads();
19879 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19880 wxPyEndAllowThreads(__tstate);
19881 if (PyErr_Occurred()) SWIG_fail;
19882 }
19883 resultobj = SWIG_From_int(static_cast< int >(result));
19884 return resultobj;
19885 fail:
19886 return NULL;
19887 }
19888
19889
19890 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19891 PyObject *resultobj = 0;
19892 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19893 int arg2 ;
19894 void *argp1 = 0 ;
19895 int res1 = 0 ;
19896 int val2 ;
19897 int ecode2 = 0 ;
19898 PyObject * obj0 = 0 ;
19899 PyObject * obj1 = 0 ;
19900 char * kwnames[] = {
19901 (char *) "self",(char *) "orient", NULL
19902 };
19903
19904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19906 if (!SWIG_IsOK(res1)) {
19907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19908 }
19909 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19910 ecode2 = SWIG_AsVal_int(obj1, &val2);
19911 if (!SWIG_IsOK(ecode2)) {
19912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19913 }
19914 arg2 = static_cast< int >(val2);
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 (arg1)->SetOrientation(arg2);
19918 wxPyEndAllowThreads(__tstate);
19919 if (PyErr_Occurred()) SWIG_fail;
19920 }
19921 resultobj = SWIG_Py_Void();
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19929 PyObject *resultobj = 0;
19930 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19931 int arg2 ;
19932 void *argp1 = 0 ;
19933 int res1 = 0 ;
19934 int val2 ;
19935 int ecode2 = 0 ;
19936 PyObject * obj0 = 0 ;
19937 PyObject * obj1 = 0 ;
19938 char * kwnames[] = {
19939 (char *) "self",(char *) "pos", NULL
19940 };
19941
19942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19944 if (!SWIG_IsOK(res1)) {
19945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19946 }
19947 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19948 ecode2 = SWIG_AsVal_int(obj1, &val2);
19949 if (!SWIG_IsOK(ecode2)) {
19950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19951 }
19952 arg2 = static_cast< int >(val2);
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 (arg1)->SetPosition(arg2);
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 resultobj = SWIG_Py_Void();
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19967 PyObject *obj;
19968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19969 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19970 return SWIG_Py_Void();
19971 }
19972
19973 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19974 return SWIG_Python_InitShadowInstance(args);
19975 }
19976
19977 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj = 0;
19979 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19980 wxMouseEvent *result = 0 ;
19981 int val1 ;
19982 int ecode1 = 0 ;
19983 PyObject * obj0 = 0 ;
19984 char * kwnames[] = {
19985 (char *) "mouseType", NULL
19986 };
19987
19988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19989 if (obj0) {
19990 ecode1 = SWIG_AsVal_int(obj0, &val1);
19991 if (!SWIG_IsOK(ecode1)) {
19992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19993 }
19994 arg1 = static_cast< wxEventType >(val1);
19995 }
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19999 wxPyEndAllowThreads(__tstate);
20000 if (PyErr_Occurred()) SWIG_fail;
20001 }
20002 {
20003 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20004 }
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20012 PyObject *resultobj = 0;
20013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20014 bool result;
20015 void *argp1 = 0 ;
20016 int res1 = 0 ;
20017 PyObject *swig_obj[1] ;
20018
20019 if (!args) SWIG_fail;
20020 swig_obj[0] = args;
20021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20022 if (!SWIG_IsOK(res1)) {
20023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20024 }
20025 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20026 {
20027 PyThreadState* __tstate = wxPyBeginAllowThreads();
20028 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20029 wxPyEndAllowThreads(__tstate);
20030 if (PyErr_Occurred()) SWIG_fail;
20031 }
20032 {
20033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20034 }
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20042 PyObject *resultobj = 0;
20043 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20044 int arg2 = (int) wxMOUSE_BTN_ANY ;
20045 bool result;
20046 void *argp1 = 0 ;
20047 int res1 = 0 ;
20048 int val2 ;
20049 int ecode2 = 0 ;
20050 PyObject * obj0 = 0 ;
20051 PyObject * obj1 = 0 ;
20052 char * kwnames[] = {
20053 (char *) "self",(char *) "but", NULL
20054 };
20055
20056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20058 if (!SWIG_IsOK(res1)) {
20059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20060 }
20061 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20062 if (obj1) {
20063 ecode2 = SWIG_AsVal_int(obj1, &val2);
20064 if (!SWIG_IsOK(ecode2)) {
20065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20066 }
20067 arg2 = static_cast< int >(val2);
20068 }
20069 {
20070 PyThreadState* __tstate = wxPyBeginAllowThreads();
20071 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20072 wxPyEndAllowThreads(__tstate);
20073 if (PyErr_Occurred()) SWIG_fail;
20074 }
20075 {
20076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20077 }
20078 return resultobj;
20079 fail:
20080 return NULL;
20081 }
20082
20083
20084 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20085 PyObject *resultobj = 0;
20086 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20087 int arg2 = (int) wxMOUSE_BTN_ANY ;
20088 bool result;
20089 void *argp1 = 0 ;
20090 int res1 = 0 ;
20091 int val2 ;
20092 int ecode2 = 0 ;
20093 PyObject * obj0 = 0 ;
20094 PyObject * obj1 = 0 ;
20095 char * kwnames[] = {
20096 (char *) "self",(char *) "but", NULL
20097 };
20098
20099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20101 if (!SWIG_IsOK(res1)) {
20102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20103 }
20104 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20105 if (obj1) {
20106 ecode2 = SWIG_AsVal_int(obj1, &val2);
20107 if (!SWIG_IsOK(ecode2)) {
20108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20109 }
20110 arg2 = static_cast< int >(val2);
20111 }
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 {
20119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20120 }
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20128 PyObject *resultobj = 0;
20129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20130 int arg2 = (int) wxMOUSE_BTN_ANY ;
20131 bool result;
20132 void *argp1 = 0 ;
20133 int res1 = 0 ;
20134 int val2 ;
20135 int ecode2 = 0 ;
20136 PyObject * obj0 = 0 ;
20137 PyObject * obj1 = 0 ;
20138 char * kwnames[] = {
20139 (char *) "self",(char *) "but", NULL
20140 };
20141
20142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20144 if (!SWIG_IsOK(res1)) {
20145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20146 }
20147 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20148 if (obj1) {
20149 ecode2 = SWIG_AsVal_int(obj1, &val2);
20150 if (!SWIG_IsOK(ecode2)) {
20151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20152 }
20153 arg2 = static_cast< int >(val2);
20154 }
20155 {
20156 PyThreadState* __tstate = wxPyBeginAllowThreads();
20157 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20158 wxPyEndAllowThreads(__tstate);
20159 if (PyErr_Occurred()) SWIG_fail;
20160 }
20161 {
20162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20163 }
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20171 PyObject *resultobj = 0;
20172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20173 int arg2 ;
20174 bool result;
20175 void *argp1 = 0 ;
20176 int res1 = 0 ;
20177 int val2 ;
20178 int ecode2 = 0 ;
20179 PyObject * obj0 = 0 ;
20180 PyObject * obj1 = 0 ;
20181 char * kwnames[] = {
20182 (char *) "self",(char *) "button", NULL
20183 };
20184
20185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20187 if (!SWIG_IsOK(res1)) {
20188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20189 }
20190 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20191 ecode2 = SWIG_AsVal_int(obj1, &val2);
20192 if (!SWIG_IsOK(ecode2)) {
20193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20194 }
20195 arg2 = static_cast< int >(val2);
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20199 wxPyEndAllowThreads(__tstate);
20200 if (PyErr_Occurred()) SWIG_fail;
20201 }
20202 {
20203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20204 }
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj = 0;
20213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20214 int arg2 ;
20215 bool result;
20216 void *argp1 = 0 ;
20217 int res1 = 0 ;
20218 int val2 ;
20219 int ecode2 = 0 ;
20220 PyObject * obj0 = 0 ;
20221 PyObject * obj1 = 0 ;
20222 char * kwnames[] = {
20223 (char *) "self",(char *) "but", NULL
20224 };
20225
20226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20228 if (!SWIG_IsOK(res1)) {
20229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20230 }
20231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20232 ecode2 = SWIG_AsVal_int(obj1, &val2);
20233 if (!SWIG_IsOK(ecode2)) {
20234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20235 }
20236 arg2 = static_cast< int >(val2);
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20240 wxPyEndAllowThreads(__tstate);
20241 if (PyErr_Occurred()) SWIG_fail;
20242 }
20243 {
20244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20245 }
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20253 PyObject *resultobj = 0;
20254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20255 int result;
20256 void *argp1 = 0 ;
20257 int res1 = 0 ;
20258 PyObject *swig_obj[1] ;
20259
20260 if (!args) SWIG_fail;
20261 swig_obj[0] = args;
20262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20263 if (!SWIG_IsOK(res1)) {
20264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20265 }
20266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20267 {
20268 PyThreadState* __tstate = wxPyBeginAllowThreads();
20269 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 resultobj = SWIG_From_int(static_cast< int >(result));
20274 return resultobj;
20275 fail:
20276 return NULL;
20277 }
20278
20279
20280 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20281 PyObject *resultobj = 0;
20282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20283 bool result;
20284 void *argp1 = 0 ;
20285 int res1 = 0 ;
20286 PyObject *swig_obj[1] ;
20287
20288 if (!args) SWIG_fail;
20289 swig_obj[0] = args;
20290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20291 if (!SWIG_IsOK(res1)) {
20292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20293 }
20294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20295 {
20296 PyThreadState* __tstate = wxPyBeginAllowThreads();
20297 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 {
20302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20303 }
20304 return resultobj;
20305 fail:
20306 return NULL;
20307 }
20308
20309
20310 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20311 PyObject *resultobj = 0;
20312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20313 bool result;
20314 void *argp1 = 0 ;
20315 int res1 = 0 ;
20316 PyObject *swig_obj[1] ;
20317
20318 if (!args) SWIG_fail;
20319 swig_obj[0] = args;
20320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20321 if (!SWIG_IsOK(res1)) {
20322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20323 }
20324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20325 {
20326 PyThreadState* __tstate = wxPyBeginAllowThreads();
20327 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 {
20332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20333 }
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341 PyObject *resultobj = 0;
20342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20343 bool result;
20344 void *argp1 = 0 ;
20345 int res1 = 0 ;
20346 PyObject *swig_obj[1] ;
20347
20348 if (!args) SWIG_fail;
20349 swig_obj[0] = args;
20350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20351 if (!SWIG_IsOK(res1)) {
20352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20353 }
20354 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20355 {
20356 PyThreadState* __tstate = wxPyBeginAllowThreads();
20357 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20358 wxPyEndAllowThreads(__tstate);
20359 if (PyErr_Occurred()) SWIG_fail;
20360 }
20361 {
20362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20363 }
20364 return resultobj;
20365 fail:
20366 return NULL;
20367 }
20368
20369
20370 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 PyObject *resultobj = 0;
20372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20373 bool result;
20374 void *argp1 = 0 ;
20375 int res1 = 0 ;
20376 PyObject *swig_obj[1] ;
20377
20378 if (!args) SWIG_fail;
20379 swig_obj[0] = args;
20380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20381 if (!SWIG_IsOK(res1)) {
20382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20383 }
20384 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20388 wxPyEndAllowThreads(__tstate);
20389 if (PyErr_Occurred()) SWIG_fail;
20390 }
20391 {
20392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20393 }
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20401 PyObject *resultobj = 0;
20402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20403 bool result;
20404 void *argp1 = 0 ;
20405 int res1 = 0 ;
20406 PyObject *swig_obj[1] ;
20407
20408 if (!args) SWIG_fail;
20409 swig_obj[0] = args;
20410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20411 if (!SWIG_IsOK(res1)) {
20412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20413 }
20414 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 {
20422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20423 }
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20431 PyObject *resultobj = 0;
20432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20433 bool result;
20434 void *argp1 = 0 ;
20435 int res1 = 0 ;
20436 PyObject *swig_obj[1] ;
20437
20438 if (!args) SWIG_fail;
20439 swig_obj[0] = args;
20440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20441 if (!SWIG_IsOK(res1)) {
20442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20443 }
20444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 {
20452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20453 }
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20461 PyObject *resultobj = 0;
20462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20463 bool result;
20464 void *argp1 = 0 ;
20465 int res1 = 0 ;
20466 PyObject *swig_obj[1] ;
20467
20468 if (!args) SWIG_fail;
20469 swig_obj[0] = args;
20470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20471 if (!SWIG_IsOK(res1)) {
20472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20473 }
20474 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 {
20482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20483 }
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20491 PyObject *resultobj = 0;
20492 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20493 bool result;
20494 void *argp1 = 0 ;
20495 int res1 = 0 ;
20496 PyObject *swig_obj[1] ;
20497
20498 if (!args) SWIG_fail;
20499 swig_obj[0] = args;
20500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20503 }
20504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20505 {
20506 PyThreadState* __tstate = wxPyBeginAllowThreads();
20507 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20508 wxPyEndAllowThreads(__tstate);
20509 if (PyErr_Occurred()) SWIG_fail;
20510 }
20511 {
20512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20513 }
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20521 PyObject *resultobj = 0;
20522 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20523 bool result;
20524 void *argp1 = 0 ;
20525 int res1 = 0 ;
20526 PyObject *swig_obj[1] ;
20527
20528 if (!args) SWIG_fail;
20529 swig_obj[0] = args;
20530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20531 if (!SWIG_IsOK(res1)) {
20532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20533 }
20534 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20538 wxPyEndAllowThreads(__tstate);
20539 if (PyErr_Occurred()) SWIG_fail;
20540 }
20541 {
20542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20543 }
20544 return resultobj;
20545 fail:
20546 return NULL;
20547 }
20548
20549
20550 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20551 PyObject *resultobj = 0;
20552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20553 bool result;
20554 void *argp1 = 0 ;
20555 int res1 = 0 ;
20556 PyObject *swig_obj[1] ;
20557
20558 if (!args) SWIG_fail;
20559 swig_obj[0] = args;
20560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20561 if (!SWIG_IsOK(res1)) {
20562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20563 }
20564 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20565 {
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 {
20572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20573 }
20574 return resultobj;
20575 fail:
20576 return NULL;
20577 }
20578
20579
20580 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20581 PyObject *resultobj = 0;
20582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20583 bool result;
20584 void *argp1 = 0 ;
20585 int res1 = 0 ;
20586 PyObject *swig_obj[1] ;
20587
20588 if (!args) SWIG_fail;
20589 swig_obj[0] = args;
20590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20591 if (!SWIG_IsOK(res1)) {
20592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20593 }
20594 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 {
20602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20603 }
20604 return resultobj;
20605 fail:
20606 return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611 PyObject *resultobj = 0;
20612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20613 bool result;
20614 void *argp1 = 0 ;
20615 int res1 = 0 ;
20616 PyObject *swig_obj[1] ;
20617
20618 if (!args) SWIG_fail;
20619 swig_obj[0] = args;
20620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20621 if (!SWIG_IsOK(res1)) {
20622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20623 }
20624 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20625 {
20626 PyThreadState* __tstate = wxPyBeginAllowThreads();
20627 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20628 wxPyEndAllowThreads(__tstate);
20629 if (PyErr_Occurred()) SWIG_fail;
20630 }
20631 {
20632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20633 }
20634 return resultobj;
20635 fail:
20636 return NULL;
20637 }
20638
20639
20640 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20641 PyObject *resultobj = 0;
20642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20643 bool result;
20644 void *argp1 = 0 ;
20645 int res1 = 0 ;
20646 PyObject *swig_obj[1] ;
20647
20648 if (!args) SWIG_fail;
20649 swig_obj[0] = args;
20650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20651 if (!SWIG_IsOK(res1)) {
20652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20653 }
20654 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 {
20662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20663 }
20664 return resultobj;
20665 fail:
20666 return NULL;
20667 }
20668
20669
20670 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20671 PyObject *resultobj = 0;
20672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20673 bool result;
20674 void *argp1 = 0 ;
20675 int res1 = 0 ;
20676 PyObject *swig_obj[1] ;
20677
20678 if (!args) SWIG_fail;
20679 swig_obj[0] = args;
20680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20681 if (!SWIG_IsOK(res1)) {
20682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20683 }
20684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 {
20692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20693 }
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20701 PyObject *resultobj = 0;
20702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20703 bool result;
20704 void *argp1 = 0 ;
20705 int res1 = 0 ;
20706 PyObject *swig_obj[1] ;
20707
20708 if (!args) SWIG_fail;
20709 swig_obj[0] = args;
20710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20711 if (!SWIG_IsOK(res1)) {
20712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20713 }
20714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20715 {
20716 PyThreadState* __tstate = wxPyBeginAllowThreads();
20717 result = (bool)(arg1)->LeftIsDown();
20718 wxPyEndAllowThreads(__tstate);
20719 if (PyErr_Occurred()) SWIG_fail;
20720 }
20721 {
20722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20723 }
20724 return resultobj;
20725 fail:
20726 return NULL;
20727 }
20728
20729
20730 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20731 PyObject *resultobj = 0;
20732 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20733 bool result;
20734 void *argp1 = 0 ;
20735 int res1 = 0 ;
20736 PyObject *swig_obj[1] ;
20737
20738 if (!args) SWIG_fail;
20739 swig_obj[0] = args;
20740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20741 if (!SWIG_IsOK(res1)) {
20742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20743 }
20744 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20745 {
20746 PyThreadState* __tstate = wxPyBeginAllowThreads();
20747 result = (bool)(arg1)->MiddleIsDown();
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 {
20752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20753 }
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20761 PyObject *resultobj = 0;
20762 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20763 bool result;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 PyObject *swig_obj[1] ;
20767
20768 if (!args) SWIG_fail;
20769 swig_obj[0] = args;
20770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20771 if (!SWIG_IsOK(res1)) {
20772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20773 }
20774 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (bool)(arg1)->RightIsDown();
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 {
20782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20783 }
20784 return resultobj;
20785 fail:
20786 return NULL;
20787 }
20788
20789
20790 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20791 PyObject *resultobj = 0;
20792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20793 bool result;
20794 void *argp1 = 0 ;
20795 int res1 = 0 ;
20796 PyObject *swig_obj[1] ;
20797
20798 if (!args) SWIG_fail;
20799 swig_obj[0] = args;
20800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20801 if (!SWIG_IsOK(res1)) {
20802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20803 }
20804 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20805 {
20806 PyThreadState* __tstate = wxPyBeginAllowThreads();
20807 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 {
20812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20813 }
20814 return resultobj;
20815 fail:
20816 return NULL;
20817 }
20818
20819
20820 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 PyObject *resultobj = 0;
20822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20823 bool result;
20824 void *argp1 = 0 ;
20825 int res1 = 0 ;
20826 PyObject *swig_obj[1] ;
20827
20828 if (!args) SWIG_fail;
20829 swig_obj[0] = args;
20830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20831 if (!SWIG_IsOK(res1)) {
20832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20833 }
20834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20835 {
20836 PyThreadState* __tstate = wxPyBeginAllowThreads();
20837 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20838 wxPyEndAllowThreads(__tstate);
20839 if (PyErr_Occurred()) SWIG_fail;
20840 }
20841 {
20842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20843 }
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20851 PyObject *resultobj = 0;
20852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20853 bool result;
20854 void *argp1 = 0 ;
20855 int res1 = 0 ;
20856 PyObject *swig_obj[1] ;
20857
20858 if (!args) SWIG_fail;
20859 swig_obj[0] = args;
20860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20861 if (!SWIG_IsOK(res1)) {
20862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20863 }
20864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 {
20872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20881 PyObject *resultobj = 0;
20882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20883 bool result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 PyObject *swig_obj[1] ;
20887
20888 if (!args) SWIG_fail;
20889 swig_obj[0] = args;
20890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20891 if (!SWIG_IsOK(res1)) {
20892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20893 }
20894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20911 PyObject *resultobj = 0;
20912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20913 wxPoint result;
20914 void *argp1 = 0 ;
20915 int res1 = 0 ;
20916 PyObject *swig_obj[1] ;
20917
20918 if (!args) SWIG_fail;
20919 swig_obj[0] = args;
20920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20921 if (!SWIG_IsOK(res1)) {
20922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20923 }
20924 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20925 {
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (arg1)->GetPosition();
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20939 PyObject *resultobj = 0;
20940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20941 long *arg2 = (long *) 0 ;
20942 long *arg3 = (long *) 0 ;
20943 void *argp1 = 0 ;
20944 int res1 = 0 ;
20945 long temp2 ;
20946 int res2 = SWIG_TMPOBJ ;
20947 long temp3 ;
20948 int res3 = SWIG_TMPOBJ ;
20949 PyObject *swig_obj[1] ;
20950
20951 arg2 = &temp2;
20952 arg3 = &temp3;
20953 if (!args) SWIG_fail;
20954 swig_obj[0] = args;
20955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20956 if (!SWIG_IsOK(res1)) {
20957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20958 }
20959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20960 {
20961 PyThreadState* __tstate = wxPyBeginAllowThreads();
20962 (arg1)->GetPosition(arg2,arg3);
20963 wxPyEndAllowThreads(__tstate);
20964 if (PyErr_Occurred()) SWIG_fail;
20965 }
20966 resultobj = SWIG_Py_Void();
20967 if (SWIG_IsTmpObj(res2)) {
20968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20969 } else {
20970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20972 }
20973 if (SWIG_IsTmpObj(res3)) {
20974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20975 } else {
20976 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20986 PyObject *resultobj = 0;
20987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20988 wxDC *arg2 = 0 ;
20989 wxPoint result;
20990 void *argp1 = 0 ;
20991 int res1 = 0 ;
20992 void *argp2 = 0 ;
20993 int res2 = 0 ;
20994 PyObject * obj0 = 0 ;
20995 PyObject * obj1 = 0 ;
20996 char * kwnames[] = {
20997 (char *) "self",(char *) "dc", NULL
20998 };
20999
21000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21004 }
21005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21006 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21007 if (!SWIG_IsOK(res2)) {
21008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21009 }
21010 if (!argp2) {
21011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21012 }
21013 arg2 = reinterpret_cast< wxDC * >(argp2);
21014 {
21015 PyThreadState* __tstate = wxPyBeginAllowThreads();
21016 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21021 return resultobj;
21022 fail:
21023 return NULL;
21024 }
21025
21026
21027 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21028 PyObject *resultobj = 0;
21029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21030 int result;
21031 void *argp1 = 0 ;
21032 int res1 = 0 ;
21033 PyObject *swig_obj[1] ;
21034
21035 if (!args) SWIG_fail;
21036 swig_obj[0] = args;
21037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21038 if (!SWIG_IsOK(res1)) {
21039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21040 }
21041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = (int)((wxMouseEvent const *)arg1)->GetX();
21045 wxPyEndAllowThreads(__tstate);
21046 if (PyErr_Occurred()) SWIG_fail;
21047 }
21048 resultobj = SWIG_From_int(static_cast< int >(result));
21049 return resultobj;
21050 fail:
21051 return NULL;
21052 }
21053
21054
21055 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21056 PyObject *resultobj = 0;
21057 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21058 int result;
21059 void *argp1 = 0 ;
21060 int res1 = 0 ;
21061 PyObject *swig_obj[1] ;
21062
21063 if (!args) SWIG_fail;
21064 swig_obj[0] = args;
21065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21066 if (!SWIG_IsOK(res1)) {
21067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21068 }
21069 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = (int)((wxMouseEvent const *)arg1)->GetY();
21073 wxPyEndAllowThreads(__tstate);
21074 if (PyErr_Occurred()) SWIG_fail;
21075 }
21076 resultobj = SWIG_From_int(static_cast< int >(result));
21077 return resultobj;
21078 fail:
21079 return NULL;
21080 }
21081
21082
21083 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21084 PyObject *resultobj = 0;
21085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21086 int result;
21087 void *argp1 = 0 ;
21088 int res1 = 0 ;
21089 PyObject *swig_obj[1] ;
21090
21091 if (!args) SWIG_fail;
21092 swig_obj[0] = args;
21093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21096 }
21097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21098 {
21099 PyThreadState* __tstate = wxPyBeginAllowThreads();
21100 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 resultobj = SWIG_From_int(static_cast< int >(result));
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(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_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21124 }
21125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 resultobj = SWIG_From_int(static_cast< int >(result));
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21140 PyObject *resultobj = 0;
21141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21142 int result;
21143 void *argp1 = 0 ;
21144 int res1 = 0 ;
21145 PyObject *swig_obj[1] ;
21146
21147 if (!args) SWIG_fail;
21148 swig_obj[0] = args;
21149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21150 if (!SWIG_IsOK(res1)) {
21151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21152 }
21153 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 resultobj = SWIG_From_int(static_cast< int >(result));
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21168 PyObject *resultobj = 0;
21169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21170 bool result;
21171 void *argp1 = 0 ;
21172 int res1 = 0 ;
21173 PyObject *swig_obj[1] ;
21174
21175 if (!args) SWIG_fail;
21176 swig_obj[0] = args;
21177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21180 }
21181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21182 {
21183 PyThreadState* __tstate = wxPyBeginAllowThreads();
21184 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 {
21189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21190 }
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21198 PyObject *resultobj = 0;
21199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21200 int arg2 ;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 int val2 ;
21204 int ecode2 = 0 ;
21205 PyObject *swig_obj[2] ;
21206
21207 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21211 }
21212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21213 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21214 if (!SWIG_IsOK(ecode2)) {
21215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21216 }
21217 arg2 = static_cast< int >(val2);
21218 if (arg1) (arg1)->m_x = arg2;
21219
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21230 int result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21240 }
21241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21242 result = (int) ((arg1)->m_x);
21243 resultobj = SWIG_From_int(static_cast< int >(result));
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21251 PyObject *resultobj = 0;
21252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21253 int arg2 ;
21254 void *argp1 = 0 ;
21255 int res1 = 0 ;
21256 int val2 ;
21257 int ecode2 = 0 ;
21258 PyObject *swig_obj[2] ;
21259
21260 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21264 }
21265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21266 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21269 }
21270 arg2 = static_cast< int >(val2);
21271 if (arg1) (arg1)->m_y = arg2;
21272
21273 resultobj = SWIG_Py_Void();
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21281 PyObject *resultobj = 0;
21282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21283 int result;
21284 void *argp1 = 0 ;
21285 int res1 = 0 ;
21286 PyObject *swig_obj[1] ;
21287
21288 if (!args) SWIG_fail;
21289 swig_obj[0] = args;
21290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21295 result = (int) ((arg1)->m_y);
21296 resultobj = SWIG_From_int(static_cast< int >(result));
21297 return resultobj;
21298 fail:
21299 return NULL;
21300 }
21301
21302
21303 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21304 PyObject *resultobj = 0;
21305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21306 bool arg2 ;
21307 void *argp1 = 0 ;
21308 int res1 = 0 ;
21309 bool val2 ;
21310 int ecode2 = 0 ;
21311 PyObject *swig_obj[2] ;
21312
21313 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21315 if (!SWIG_IsOK(res1)) {
21316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21317 }
21318 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21319 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21320 if (!SWIG_IsOK(ecode2)) {
21321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21322 }
21323 arg2 = static_cast< bool >(val2);
21324 if (arg1) (arg1)->m_leftDown = arg2;
21325
21326 resultobj = SWIG_Py_Void();
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21334 PyObject *resultobj = 0;
21335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21336 bool result;
21337 void *argp1 = 0 ;
21338 int res1 = 0 ;
21339 PyObject *swig_obj[1] ;
21340
21341 if (!args) SWIG_fail;
21342 swig_obj[0] = args;
21343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21344 if (!SWIG_IsOK(res1)) {
21345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21346 }
21347 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21348 result = (bool) ((arg1)->m_leftDown);
21349 {
21350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21351 }
21352 return resultobj;
21353 fail:
21354 return NULL;
21355 }
21356
21357
21358 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21359 PyObject *resultobj = 0;
21360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21361 bool arg2 ;
21362 void *argp1 = 0 ;
21363 int res1 = 0 ;
21364 bool val2 ;
21365 int ecode2 = 0 ;
21366 PyObject *swig_obj[2] ;
21367
21368 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21370 if (!SWIG_IsOK(res1)) {
21371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21372 }
21373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21374 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21375 if (!SWIG_IsOK(ecode2)) {
21376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21377 }
21378 arg2 = static_cast< bool >(val2);
21379 if (arg1) (arg1)->m_middleDown = arg2;
21380
21381 resultobj = SWIG_Py_Void();
21382 return resultobj;
21383 fail:
21384 return NULL;
21385 }
21386
21387
21388 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21389 PyObject *resultobj = 0;
21390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21391 bool result;
21392 void *argp1 = 0 ;
21393 int res1 = 0 ;
21394 PyObject *swig_obj[1] ;
21395
21396 if (!args) SWIG_fail;
21397 swig_obj[0] = args;
21398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21399 if (!SWIG_IsOK(res1)) {
21400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21401 }
21402 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21403 result = (bool) ((arg1)->m_middleDown);
21404 {
21405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21406 }
21407 return resultobj;
21408 fail:
21409 return NULL;
21410 }
21411
21412
21413 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21414 PyObject *resultobj = 0;
21415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21416 bool arg2 ;
21417 void *argp1 = 0 ;
21418 int res1 = 0 ;
21419 bool val2 ;
21420 int ecode2 = 0 ;
21421 PyObject *swig_obj[2] ;
21422
21423 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21425 if (!SWIG_IsOK(res1)) {
21426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21427 }
21428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21429 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21430 if (!SWIG_IsOK(ecode2)) {
21431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21432 }
21433 arg2 = static_cast< bool >(val2);
21434 if (arg1) (arg1)->m_rightDown = arg2;
21435
21436 resultobj = SWIG_Py_Void();
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21444 PyObject *resultobj = 0;
21445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21446 bool result;
21447 void *argp1 = 0 ;
21448 int res1 = 0 ;
21449 PyObject *swig_obj[1] ;
21450
21451 if (!args) SWIG_fail;
21452 swig_obj[0] = args;
21453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21456 }
21457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21458 result = (bool) ((arg1)->m_rightDown);
21459 {
21460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21461 }
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21471 bool arg2 ;
21472 void *argp1 = 0 ;
21473 int res1 = 0 ;
21474 bool val2 ;
21475 int ecode2 = 0 ;
21476 PyObject *swig_obj[2] ;
21477
21478 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21480 if (!SWIG_IsOK(res1)) {
21481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21482 }
21483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21484 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21485 if (!SWIG_IsOK(ecode2)) {
21486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21487 }
21488 arg2 = static_cast< bool >(val2);
21489 if (arg1) (arg1)->m_controlDown = arg2;
21490
21491 resultobj = SWIG_Py_Void();
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21499 PyObject *resultobj = 0;
21500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21501 bool result;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 PyObject *swig_obj[1] ;
21505
21506 if (!args) SWIG_fail;
21507 swig_obj[0] = args;
21508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21511 }
21512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21513 result = (bool) ((arg1)->m_controlDown);
21514 {
21515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21516 }
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21524 PyObject *resultobj = 0;
21525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21526 bool arg2 ;
21527 void *argp1 = 0 ;
21528 int res1 = 0 ;
21529 bool val2 ;
21530 int ecode2 = 0 ;
21531 PyObject *swig_obj[2] ;
21532
21533 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21539 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21540 if (!SWIG_IsOK(ecode2)) {
21541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21542 }
21543 arg2 = static_cast< bool >(val2);
21544 if (arg1) (arg1)->m_shiftDown = arg2;
21545
21546 resultobj = SWIG_Py_Void();
21547 return resultobj;
21548 fail:
21549 return NULL;
21550 }
21551
21552
21553 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21554 PyObject *resultobj = 0;
21555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21556 bool result;
21557 void *argp1 = 0 ;
21558 int res1 = 0 ;
21559 PyObject *swig_obj[1] ;
21560
21561 if (!args) SWIG_fail;
21562 swig_obj[0] = args;
21563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21564 if (!SWIG_IsOK(res1)) {
21565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21566 }
21567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21568 result = (bool) ((arg1)->m_shiftDown);
21569 {
21570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21571 }
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21579 PyObject *resultobj = 0;
21580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21581 bool arg2 ;
21582 void *argp1 = 0 ;
21583 int res1 = 0 ;
21584 bool val2 ;
21585 int ecode2 = 0 ;
21586 PyObject *swig_obj[2] ;
21587
21588 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21590 if (!SWIG_IsOK(res1)) {
21591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21592 }
21593 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21594 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21595 if (!SWIG_IsOK(ecode2)) {
21596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21597 }
21598 arg2 = static_cast< bool >(val2);
21599 if (arg1) (arg1)->m_altDown = arg2;
21600
21601 resultobj = SWIG_Py_Void();
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21609 PyObject *resultobj = 0;
21610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21611 bool result;
21612 void *argp1 = 0 ;
21613 int res1 = 0 ;
21614 PyObject *swig_obj[1] ;
21615
21616 if (!args) SWIG_fail;
21617 swig_obj[0] = args;
21618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21619 if (!SWIG_IsOK(res1)) {
21620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21621 }
21622 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21623 result = (bool) ((arg1)->m_altDown);
21624 {
21625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21626 }
21627 return resultobj;
21628 fail:
21629 return NULL;
21630 }
21631
21632
21633 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 PyObject *resultobj = 0;
21635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21636 bool arg2 ;
21637 void *argp1 = 0 ;
21638 int res1 = 0 ;
21639 bool val2 ;
21640 int ecode2 = 0 ;
21641 PyObject *swig_obj[2] ;
21642
21643 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21645 if (!SWIG_IsOK(res1)) {
21646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21647 }
21648 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21649 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21650 if (!SWIG_IsOK(ecode2)) {
21651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21652 }
21653 arg2 = static_cast< bool >(val2);
21654 if (arg1) (arg1)->m_metaDown = arg2;
21655
21656 resultobj = SWIG_Py_Void();
21657 return resultobj;
21658 fail:
21659 return NULL;
21660 }
21661
21662
21663 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21664 PyObject *resultobj = 0;
21665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21666 bool result;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 PyObject *swig_obj[1] ;
21670
21671 if (!args) SWIG_fail;
21672 swig_obj[0] = args;
21673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21674 if (!SWIG_IsOK(res1)) {
21675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21676 }
21677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21678 result = (bool) ((arg1)->m_metaDown);
21679 {
21680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21681 }
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21691 int arg2 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 int val2 ;
21695 int ecode2 = 0 ;
21696 PyObject *swig_obj[2] ;
21697
21698 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21705 if (!SWIG_IsOK(ecode2)) {
21706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21707 }
21708 arg2 = static_cast< int >(val2);
21709 if (arg1) (arg1)->m_wheelRotation = arg2;
21710
21711 resultobj = SWIG_Py_Void();
21712 return resultobj;
21713 fail:
21714 return NULL;
21715 }
21716
21717
21718 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21719 PyObject *resultobj = 0;
21720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21721 int result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 PyObject *swig_obj[1] ;
21725
21726 if (!args) SWIG_fail;
21727 swig_obj[0] = args;
21728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21729 if (!SWIG_IsOK(res1)) {
21730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21731 }
21732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21733 result = (int) ((arg1)->m_wheelRotation);
21734 resultobj = SWIG_From_int(static_cast< int >(result));
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *resultobj = 0;
21743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21744 int arg2 ;
21745 void *argp1 = 0 ;
21746 int res1 = 0 ;
21747 int val2 ;
21748 int ecode2 = 0 ;
21749 PyObject *swig_obj[2] ;
21750
21751 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21753 if (!SWIG_IsOK(res1)) {
21754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21755 }
21756 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21757 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21758 if (!SWIG_IsOK(ecode2)) {
21759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21760 }
21761 arg2 = static_cast< int >(val2);
21762 if (arg1) (arg1)->m_wheelDelta = arg2;
21763
21764 resultobj = SWIG_Py_Void();
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21772 PyObject *resultobj = 0;
21773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21774 int result;
21775 void *argp1 = 0 ;
21776 int res1 = 0 ;
21777 PyObject *swig_obj[1] ;
21778
21779 if (!args) SWIG_fail;
21780 swig_obj[0] = args;
21781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21782 if (!SWIG_IsOK(res1)) {
21783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21784 }
21785 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21786 result = (int) ((arg1)->m_wheelDelta);
21787 resultobj = SWIG_From_int(static_cast< int >(result));
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21797 int arg2 ;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 int val2 ;
21801 int ecode2 = 0 ;
21802 PyObject *swig_obj[2] ;
21803
21804 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21808 }
21809 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21811 if (!SWIG_IsOK(ecode2)) {
21812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21813 }
21814 arg2 = static_cast< int >(val2);
21815 if (arg1) (arg1)->m_linesPerAction = arg2;
21816
21817 resultobj = SWIG_Py_Void();
21818 return resultobj;
21819 fail:
21820 return NULL;
21821 }
21822
21823
21824 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21825 PyObject *resultobj = 0;
21826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21827 int result;
21828 void *argp1 = 0 ;
21829 int res1 = 0 ;
21830 PyObject *swig_obj[1] ;
21831
21832 if (!args) SWIG_fail;
21833 swig_obj[0] = args;
21834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21835 if (!SWIG_IsOK(res1)) {
21836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21837 }
21838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21839 result = (int) ((arg1)->m_linesPerAction);
21840 resultobj = SWIG_From_int(static_cast< int >(result));
21841 return resultobj;
21842 fail:
21843 return NULL;
21844 }
21845
21846
21847 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21848 PyObject *obj;
21849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21850 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21851 return SWIG_Py_Void();
21852 }
21853
21854 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21855 return SWIG_Python_InitShadowInstance(args);
21856 }
21857
21858 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21859 PyObject *resultobj = 0;
21860 int arg1 = (int) 0 ;
21861 int arg2 = (int) 0 ;
21862 wxSetCursorEvent *result = 0 ;
21863 int val1 ;
21864 int ecode1 = 0 ;
21865 int val2 ;
21866 int ecode2 = 0 ;
21867 PyObject * obj0 = 0 ;
21868 PyObject * obj1 = 0 ;
21869 char * kwnames[] = {
21870 (char *) "x",(char *) "y", NULL
21871 };
21872
21873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21874 if (obj0) {
21875 ecode1 = SWIG_AsVal_int(obj0, &val1);
21876 if (!SWIG_IsOK(ecode1)) {
21877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21878 }
21879 arg1 = static_cast< int >(val1);
21880 }
21881 if (obj1) {
21882 ecode2 = SWIG_AsVal_int(obj1, &val2);
21883 if (!SWIG_IsOK(ecode2)) {
21884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21885 }
21886 arg2 = static_cast< int >(val2);
21887 }
21888 {
21889 PyThreadState* __tstate = wxPyBeginAllowThreads();
21890 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21891 wxPyEndAllowThreads(__tstate);
21892 if (PyErr_Occurred()) SWIG_fail;
21893 }
21894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21895 return resultobj;
21896 fail:
21897 return NULL;
21898 }
21899
21900
21901 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21902 PyObject *resultobj = 0;
21903 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21904 int result;
21905 void *argp1 = 0 ;
21906 int res1 = 0 ;
21907 PyObject *swig_obj[1] ;
21908
21909 if (!args) SWIG_fail;
21910 swig_obj[0] = args;
21911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21912 if (!SWIG_IsOK(res1)) {
21913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21914 }
21915 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21916 {
21917 PyThreadState* __tstate = wxPyBeginAllowThreads();
21918 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 resultobj = SWIG_From_int(static_cast< int >(result));
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21930 PyObject *resultobj = 0;
21931 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21932 int result;
21933 void *argp1 = 0 ;
21934 int res1 = 0 ;
21935 PyObject *swig_obj[1] ;
21936
21937 if (!args) SWIG_fail;
21938 swig_obj[0] = args;
21939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21940 if (!SWIG_IsOK(res1)) {
21941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21942 }
21943 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21944 {
21945 PyThreadState* __tstate = wxPyBeginAllowThreads();
21946 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 resultobj = SWIG_From_int(static_cast< int >(result));
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21958 PyObject *resultobj = 0;
21959 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21960 wxCursor *arg2 = 0 ;
21961 void *argp1 = 0 ;
21962 int res1 = 0 ;
21963 void *argp2 = 0 ;
21964 int res2 = 0 ;
21965 PyObject * obj0 = 0 ;
21966 PyObject * obj1 = 0 ;
21967 char * kwnames[] = {
21968 (char *) "self",(char *) "cursor", NULL
21969 };
21970
21971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21973 if (!SWIG_IsOK(res1)) {
21974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21975 }
21976 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21978 if (!SWIG_IsOK(res2)) {
21979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21980 }
21981 if (!argp2) {
21982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21983 }
21984 arg2 = reinterpret_cast< wxCursor * >(argp2);
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 (arg1)->SetCursor((wxCursor const &)*arg2);
21988 wxPyEndAllowThreads(__tstate);
21989 if (PyErr_Occurred()) SWIG_fail;
21990 }
21991 resultobj = SWIG_Py_Void();
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21999 PyObject *resultobj = 0;
22000 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22001 wxCursor *result = 0 ;
22002 void *argp1 = 0 ;
22003 int res1 = 0 ;
22004 PyObject *swig_obj[1] ;
22005
22006 if (!args) SWIG_fail;
22007 swig_obj[0] = args;
22008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22009 if (!SWIG_IsOK(res1)) {
22010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22011 }
22012 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 {
22016 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22017 result = (wxCursor *) &_result_ref;
22018 }
22019 wxPyEndAllowThreads(__tstate);
22020 if (PyErr_Occurred()) SWIG_fail;
22021 }
22022 {
22023 wxCursor* resultptr = new wxCursor(*result);
22024 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22033 PyObject *resultobj = 0;
22034 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22035 bool result;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 PyObject *swig_obj[1] ;
22039
22040 if (!args) SWIG_fail;
22041 swig_obj[0] = args;
22042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22045 }
22046 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 {
22054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22055 }
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22063 PyObject *obj;
22064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22065 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22066 return SWIG_Py_Void();
22067 }
22068
22069 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 return SWIG_Python_InitShadowInstance(args);
22071 }
22072
22073 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22074 PyObject *resultobj = 0;
22075 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22076 wxKeyEvent *result = 0 ;
22077 int val1 ;
22078 int ecode1 = 0 ;
22079 PyObject * obj0 = 0 ;
22080 char * kwnames[] = {
22081 (char *) "eventType", NULL
22082 };
22083
22084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22085 if (obj0) {
22086 ecode1 = SWIG_AsVal_int(obj0, &val1);
22087 if (!SWIG_IsOK(ecode1)) {
22088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22089 }
22090 arg1 = static_cast< wxEventType >(val1);
22091 }
22092 {
22093 PyThreadState* __tstate = wxPyBeginAllowThreads();
22094 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22106 PyObject *resultobj = 0;
22107 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22108 int result;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 PyObject *swig_obj[1] ;
22112
22113 if (!args) SWIG_fail;
22114 swig_obj[0] = args;
22115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22116 if (!SWIG_IsOK(res1)) {
22117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22118 }
22119 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 resultobj = SWIG_From_int(static_cast< int >(result));
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22134 PyObject *resultobj = 0;
22135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22136 bool result;
22137 void *argp1 = 0 ;
22138 int res1 = 0 ;
22139 PyObject *swig_obj[1] ;
22140
22141 if (!args) SWIG_fail;
22142 swig_obj[0] = args;
22143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22146 }
22147 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 {
22155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22156 }
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22164 PyObject *resultobj = 0;
22165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22166 bool result;
22167 void *argp1 = 0 ;
22168 int res1 = 0 ;
22169 PyObject *swig_obj[1] ;
22170
22171 if (!args) SWIG_fail;
22172 swig_obj[0] = args;
22173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22174 if (!SWIG_IsOK(res1)) {
22175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22176 }
22177 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22178 {
22179 PyThreadState* __tstate = wxPyBeginAllowThreads();
22180 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 {
22185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22186 }
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22194 PyObject *resultobj = 0;
22195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22196 bool result;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 PyObject *swig_obj[1] ;
22200
22201 if (!args) SWIG_fail;
22202 swig_obj[0] = args;
22203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22204 if (!SWIG_IsOK(res1)) {
22205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22206 }
22207 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 {
22215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22216 }
22217 return resultobj;
22218 fail:
22219 return NULL;
22220 }
22221
22222
22223 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22224 PyObject *resultobj = 0;
22225 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22226 bool result;
22227 void *argp1 = 0 ;
22228 int res1 = 0 ;
22229 PyObject *swig_obj[1] ;
22230
22231 if (!args) SWIG_fail;
22232 swig_obj[0] = args;
22233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22234 if (!SWIG_IsOK(res1)) {
22235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22236 }
22237 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 {
22245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22246 }
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *resultobj = 0;
22255 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22256 bool result;
22257 void *argp1 = 0 ;
22258 int res1 = 0 ;
22259 PyObject *swig_obj[1] ;
22260
22261 if (!args) SWIG_fail;
22262 swig_obj[0] = args;
22263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22266 }
22267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 {
22275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22284 PyObject *resultobj = 0;
22285 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22286 bool result;
22287 void *argp1 = 0 ;
22288 int res1 = 0 ;
22289 PyObject *swig_obj[1] ;
22290
22291 if (!args) SWIG_fail;
22292 swig_obj[0] = args;
22293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22294 if (!SWIG_IsOK(res1)) {
22295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22296 }
22297 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 {
22305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22306 }
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22314 PyObject *resultobj = 0;
22315 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22316 int result;
22317 void *argp1 = 0 ;
22318 int res1 = 0 ;
22319 PyObject *swig_obj[1] ;
22320
22321 if (!args) SWIG_fail;
22322 swig_obj[0] = args;
22323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22324 if (!SWIG_IsOK(res1)) {
22325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22326 }
22327 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 resultobj = SWIG_From_int(static_cast< int >(result));
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22342 PyObject *resultobj = 0;
22343 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22344 int result;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 PyObject *swig_obj[1] ;
22348
22349 if (!args) SWIG_fail;
22350 swig_obj[0] = args;
22351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22352 if (!SWIG_IsOK(res1)) {
22353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22354 }
22355 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 resultobj = SWIG_From_int(static_cast< int >(result));
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj = 0;
22371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22372 int arg2 ;
22373 void *argp1 = 0 ;
22374 int res1 = 0 ;
22375 int val2 ;
22376 int ecode2 = 0 ;
22377 PyObject * obj0 = 0 ;
22378 PyObject * obj1 = 0 ;
22379 char * kwnames[] = {
22380 (char *) "self",(char *) "uniChar", NULL
22381 };
22382
22383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 ecode2 = SWIG_AsVal_int(obj1, &val2);
22390 if (!SWIG_IsOK(ecode2)) {
22391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22392 }
22393 arg2 = static_cast< int >(val2);
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 resultobj = SWIG_Py_Void();
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22408 PyObject *resultobj = 0;
22409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22410 unsigned int result;
22411 void *argp1 = 0 ;
22412 int res1 = 0 ;
22413 PyObject *swig_obj[1] ;
22414
22415 if (!args) SWIG_fail;
22416 swig_obj[0] = args;
22417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22418 if (!SWIG_IsOK(res1)) {
22419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22420 }
22421 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22425 wxPyEndAllowThreads(__tstate);
22426 if (PyErr_Occurred()) SWIG_fail;
22427 }
22428 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22436 PyObject *resultobj = 0;
22437 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22438 unsigned int result;
22439 void *argp1 = 0 ;
22440 int res1 = 0 ;
22441 PyObject *swig_obj[1] ;
22442
22443 if (!args) SWIG_fail;
22444 swig_obj[0] = args;
22445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22446 if (!SWIG_IsOK(res1)) {
22447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22448 }
22449 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22464 PyObject *resultobj = 0;
22465 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22466 wxPoint result;
22467 void *argp1 = 0 ;
22468 int res1 = 0 ;
22469 PyObject *swig_obj[1] ;
22470
22471 if (!args) SWIG_fail;
22472 swig_obj[0] = args;
22473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22474 if (!SWIG_IsOK(res1)) {
22475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22476 }
22477 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 result = (arg1)->GetPosition();
22481 wxPyEndAllowThreads(__tstate);
22482 if (PyErr_Occurred()) SWIG_fail;
22483 }
22484 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22485 return resultobj;
22486 fail:
22487 return NULL;
22488 }
22489
22490
22491 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22492 PyObject *resultobj = 0;
22493 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22494 long *arg2 = (long *) 0 ;
22495 long *arg3 = (long *) 0 ;
22496 void *argp1 = 0 ;
22497 int res1 = 0 ;
22498 long temp2 ;
22499 int res2 = SWIG_TMPOBJ ;
22500 long temp3 ;
22501 int res3 = SWIG_TMPOBJ ;
22502 PyObject *swig_obj[1] ;
22503
22504 arg2 = &temp2;
22505 arg3 = &temp3;
22506 if (!args) SWIG_fail;
22507 swig_obj[0] = args;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 (arg1)->GetPosition(arg2,arg3);
22516 wxPyEndAllowThreads(__tstate);
22517 if (PyErr_Occurred()) SWIG_fail;
22518 }
22519 resultobj = SWIG_Py_Void();
22520 if (SWIG_IsTmpObj(res2)) {
22521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22522 } else {
22523 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22525 }
22526 if (SWIG_IsTmpObj(res3)) {
22527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22528 } else {
22529 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22531 }
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22539 PyObject *resultobj = 0;
22540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22541 int result;
22542 void *argp1 = 0 ;
22543 int res1 = 0 ;
22544 PyObject *swig_obj[1] ;
22545
22546 if (!args) SWIG_fail;
22547 swig_obj[0] = args;
22548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22549 if (!SWIG_IsOK(res1)) {
22550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22551 }
22552 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 result = (int)((wxKeyEvent const *)arg1)->GetX();
22556 wxPyEndAllowThreads(__tstate);
22557 if (PyErr_Occurred()) SWIG_fail;
22558 }
22559 resultobj = SWIG_From_int(static_cast< int >(result));
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22567 PyObject *resultobj = 0;
22568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22569 int result;
22570 void *argp1 = 0 ;
22571 int res1 = 0 ;
22572 PyObject *swig_obj[1] ;
22573
22574 if (!args) SWIG_fail;
22575 swig_obj[0] = args;
22576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22577 if (!SWIG_IsOK(res1)) {
22578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22579 }
22580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 result = (int)((wxKeyEvent const *)arg1)->GetY();
22584 wxPyEndAllowThreads(__tstate);
22585 if (PyErr_Occurred()) SWIG_fail;
22586 }
22587 resultobj = SWIG_From_int(static_cast< int >(result));
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *resultobj = 0;
22596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22597 int arg2 ;
22598 void *argp1 = 0 ;
22599 int res1 = 0 ;
22600 int val2 ;
22601 int ecode2 = 0 ;
22602 PyObject *swig_obj[2] ;
22603
22604 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22606 if (!SWIG_IsOK(res1)) {
22607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22608 }
22609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22610 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22611 if (!SWIG_IsOK(ecode2)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22613 }
22614 arg2 = static_cast< int >(val2);
22615 if (arg1) (arg1)->m_x = arg2;
22616
22617 resultobj = SWIG_Py_Void();
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 int result;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 PyObject *swig_obj[1] ;
22631
22632 if (!args) SWIG_fail;
22633 swig_obj[0] = args;
22634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22639 result = (int) ((arg1)->m_x);
22640 resultobj = SWIG_From_int(static_cast< int >(result));
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22648 PyObject *resultobj = 0;
22649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22650 int arg2 ;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 int val2 ;
22654 int ecode2 = 0 ;
22655 PyObject *swig_obj[2] ;
22656
22657 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22661 }
22662 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22663 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22664 if (!SWIG_IsOK(ecode2)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22666 }
22667 arg2 = static_cast< int >(val2);
22668 if (arg1) (arg1)->m_y = arg2;
22669
22670 resultobj = SWIG_Py_Void();
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 int result;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 PyObject *swig_obj[1] ;
22684
22685 if (!args) SWIG_fail;
22686 swig_obj[0] = args;
22687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22690 }
22691 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22692 result = (int) ((arg1)->m_y);
22693 resultobj = SWIG_From_int(static_cast< int >(result));
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22701 PyObject *resultobj = 0;
22702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22703 long arg2 ;
22704 void *argp1 = 0 ;
22705 int res1 = 0 ;
22706 long val2 ;
22707 int ecode2 = 0 ;
22708 PyObject *swig_obj[2] ;
22709
22710 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22712 if (!SWIG_IsOK(res1)) {
22713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22714 }
22715 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22716 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22717 if (!SWIG_IsOK(ecode2)) {
22718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22719 }
22720 arg2 = static_cast< long >(val2);
22721 if (arg1) (arg1)->m_keyCode = arg2;
22722
22723 resultobj = SWIG_Py_Void();
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22731 PyObject *resultobj = 0;
22732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22733 long result;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 PyObject *swig_obj[1] ;
22737
22738 if (!args) SWIG_fail;
22739 swig_obj[0] = args;
22740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22741 if (!SWIG_IsOK(res1)) {
22742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22743 }
22744 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22745 result = (long) ((arg1)->m_keyCode);
22746 resultobj = SWIG_From_long(static_cast< long >(result));
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22754 PyObject *resultobj = 0;
22755 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22756 bool arg2 ;
22757 void *argp1 = 0 ;
22758 int res1 = 0 ;
22759 bool val2 ;
22760 int ecode2 = 0 ;
22761 PyObject *swig_obj[2] ;
22762
22763 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22765 if (!SWIG_IsOK(res1)) {
22766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22767 }
22768 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22769 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22770 if (!SWIG_IsOK(ecode2)) {
22771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22772 }
22773 arg2 = static_cast< bool >(val2);
22774 if (arg1) (arg1)->m_controlDown = arg2;
22775
22776 resultobj = SWIG_Py_Void();
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 PyObject *resultobj = 0;
22785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22786 bool result;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 PyObject *swig_obj[1] ;
22790
22791 if (!args) SWIG_fail;
22792 swig_obj[0] = args;
22793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22794 if (!SWIG_IsOK(res1)) {
22795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22796 }
22797 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22798 result = (bool) ((arg1)->m_controlDown);
22799 {
22800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22801 }
22802 return resultobj;
22803 fail:
22804 return NULL;
22805 }
22806
22807
22808 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22809 PyObject *resultobj = 0;
22810 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22811 bool arg2 ;
22812 void *argp1 = 0 ;
22813 int res1 = 0 ;
22814 bool val2 ;
22815 int ecode2 = 0 ;
22816 PyObject *swig_obj[2] ;
22817
22818 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22820 if (!SWIG_IsOK(res1)) {
22821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22822 }
22823 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22824 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22825 if (!SWIG_IsOK(ecode2)) {
22826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22827 }
22828 arg2 = static_cast< bool >(val2);
22829 if (arg1) (arg1)->m_shiftDown = arg2;
22830
22831 resultobj = SWIG_Py_Void();
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839 PyObject *resultobj = 0;
22840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22841 bool result;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 PyObject *swig_obj[1] ;
22845
22846 if (!args) SWIG_fail;
22847 swig_obj[0] = args;
22848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22851 }
22852 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22853 result = (bool) ((arg1)->m_shiftDown);
22854 {
22855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22856 }
22857 return resultobj;
22858 fail:
22859 return NULL;
22860 }
22861
22862
22863 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22864 PyObject *resultobj = 0;
22865 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22866 bool arg2 ;
22867 void *argp1 = 0 ;
22868 int res1 = 0 ;
22869 bool val2 ;
22870 int ecode2 = 0 ;
22871 PyObject *swig_obj[2] ;
22872
22873 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22877 }
22878 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22879 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22880 if (!SWIG_IsOK(ecode2)) {
22881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22882 }
22883 arg2 = static_cast< bool >(val2);
22884 if (arg1) (arg1)->m_altDown = arg2;
22885
22886 resultobj = SWIG_Py_Void();
22887 return resultobj;
22888 fail:
22889 return NULL;
22890 }
22891
22892
22893 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22894 PyObject *resultobj = 0;
22895 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22896 bool result;
22897 void *argp1 = 0 ;
22898 int res1 = 0 ;
22899 PyObject *swig_obj[1] ;
22900
22901 if (!args) SWIG_fail;
22902 swig_obj[0] = args;
22903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22904 if (!SWIG_IsOK(res1)) {
22905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22906 }
22907 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22908 result = (bool) ((arg1)->m_altDown);
22909 {
22910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22911 }
22912 return resultobj;
22913 fail:
22914 return NULL;
22915 }
22916
22917
22918 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22919 PyObject *resultobj = 0;
22920 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22921 bool arg2 ;
22922 void *argp1 = 0 ;
22923 int res1 = 0 ;
22924 bool val2 ;
22925 int ecode2 = 0 ;
22926 PyObject *swig_obj[2] ;
22927
22928 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22930 if (!SWIG_IsOK(res1)) {
22931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22932 }
22933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22934 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22935 if (!SWIG_IsOK(ecode2)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22937 }
22938 arg2 = static_cast< bool >(val2);
22939 if (arg1) (arg1)->m_metaDown = arg2;
22940
22941 resultobj = SWIG_Py_Void();
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22949 PyObject *resultobj = 0;
22950 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22951 bool result;
22952 void *argp1 = 0 ;
22953 int res1 = 0 ;
22954 PyObject *swig_obj[1] ;
22955
22956 if (!args) SWIG_fail;
22957 swig_obj[0] = args;
22958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22959 if (!SWIG_IsOK(res1)) {
22960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22961 }
22962 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22963 result = (bool) ((arg1)->m_metaDown);
22964 {
22965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22966 }
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22974 PyObject *resultobj = 0;
22975 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22976 bool arg2 ;
22977 void *argp1 = 0 ;
22978 int res1 = 0 ;
22979 bool val2 ;
22980 int ecode2 = 0 ;
22981 PyObject *swig_obj[2] ;
22982
22983 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22987 }
22988 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22989 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22990 if (!SWIG_IsOK(ecode2)) {
22991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22992 }
22993 arg2 = static_cast< bool >(val2);
22994 if (arg1) (arg1)->m_scanCode = arg2;
22995
22996 resultobj = SWIG_Py_Void();
22997 return resultobj;
22998 fail:
22999 return NULL;
23000 }
23001
23002
23003 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23004 PyObject *resultobj = 0;
23005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23006 bool result;
23007 void *argp1 = 0 ;
23008 int res1 = 0 ;
23009 PyObject *swig_obj[1] ;
23010
23011 if (!args) SWIG_fail;
23012 swig_obj[0] = args;
23013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23016 }
23017 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23018 result = (bool) ((arg1)->m_scanCode);
23019 {
23020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23021 }
23022 return resultobj;
23023 fail:
23024 return NULL;
23025 }
23026
23027
23028 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23029 PyObject *resultobj = 0;
23030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23031 unsigned int arg2 ;
23032 void *argp1 = 0 ;
23033 int res1 = 0 ;
23034 unsigned int val2 ;
23035 int ecode2 = 0 ;
23036 PyObject *swig_obj[2] ;
23037
23038 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23040 if (!SWIG_IsOK(res1)) {
23041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23042 }
23043 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23044 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23045 if (!SWIG_IsOK(ecode2)) {
23046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23047 }
23048 arg2 = static_cast< unsigned int >(val2);
23049 if (arg1) (arg1)->m_rawCode = arg2;
23050
23051 resultobj = SWIG_Py_Void();
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23059 PyObject *resultobj = 0;
23060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23061 unsigned int result;
23062 void *argp1 = 0 ;
23063 int res1 = 0 ;
23064 PyObject *swig_obj[1] ;
23065
23066 if (!args) SWIG_fail;
23067 swig_obj[0] = args;
23068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23069 if (!SWIG_IsOK(res1)) {
23070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23071 }
23072 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23073 result = (unsigned int) ((arg1)->m_rawCode);
23074 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23084 unsigned int arg2 ;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 unsigned int val2 ;
23088 int ecode2 = 0 ;
23089 PyObject *swig_obj[2] ;
23090
23091 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23093 if (!SWIG_IsOK(res1)) {
23094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23095 }
23096 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23097 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23098 if (!SWIG_IsOK(ecode2)) {
23099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23100 }
23101 arg2 = static_cast< unsigned int >(val2);
23102 if (arg1) (arg1)->m_rawFlags = arg2;
23103
23104 resultobj = SWIG_Py_Void();
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23112 PyObject *resultobj = 0;
23113 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23114 unsigned int result;
23115 void *argp1 = 0 ;
23116 int res1 = 0 ;
23117 PyObject *swig_obj[1] ;
23118
23119 if (!args) SWIG_fail;
23120 swig_obj[0] = args;
23121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23122 if (!SWIG_IsOK(res1)) {
23123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23124 }
23125 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23126 result = (unsigned int) ((arg1)->m_rawFlags);
23127 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23135 PyObject *obj;
23136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23137 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23138 return SWIG_Py_Void();
23139 }
23140
23141 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 return SWIG_Python_InitShadowInstance(args);
23143 }
23144
23145 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23146 PyObject *resultobj = 0;
23147 wxSize const &arg1_defvalue = wxDefaultSize ;
23148 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23149 int arg2 = (int) 0 ;
23150 wxSizeEvent *result = 0 ;
23151 wxSize temp1 ;
23152 int val2 ;
23153 int ecode2 = 0 ;
23154 PyObject * obj0 = 0 ;
23155 PyObject * obj1 = 0 ;
23156 char * kwnames[] = {
23157 (char *) "sz",(char *) "winid", NULL
23158 };
23159
23160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23161 if (obj0) {
23162 {
23163 arg1 = &temp1;
23164 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23165 }
23166 }
23167 if (obj1) {
23168 ecode2 = SWIG_AsVal_int(obj1, &val2);
23169 if (!SWIG_IsOK(ecode2)) {
23170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23171 }
23172 arg2 = static_cast< int >(val2);
23173 }
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23177 wxPyEndAllowThreads(__tstate);
23178 if (PyErr_Occurred()) SWIG_fail;
23179 }
23180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23188 PyObject *resultobj = 0;
23189 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23190 wxSize result;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 PyObject *swig_obj[1] ;
23194
23195 if (!args) SWIG_fail;
23196 swig_obj[0] = args;
23197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23200 }
23201 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = ((wxSizeEvent const *)arg1)->GetSize();
23205 wxPyEndAllowThreads(__tstate);
23206 if (PyErr_Occurred()) SWIG_fail;
23207 }
23208 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23209 return resultobj;
23210 fail:
23211 return NULL;
23212 }
23213
23214
23215 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23216 PyObject *resultobj = 0;
23217 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23218 wxRect result;
23219 void *argp1 = 0 ;
23220 int res1 = 0 ;
23221 PyObject *swig_obj[1] ;
23222
23223 if (!args) SWIG_fail;
23224 swig_obj[0] = args;
23225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23226 if (!SWIG_IsOK(res1)) {
23227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23228 }
23229 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = ((wxSizeEvent const *)arg1)->GetRect();
23233 wxPyEndAllowThreads(__tstate);
23234 if (PyErr_Occurred()) SWIG_fail;
23235 }
23236 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23244 PyObject *resultobj = 0;
23245 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23246 wxRect arg2 ;
23247 void *argp1 = 0 ;
23248 int res1 = 0 ;
23249 void *argp2 ;
23250 int res2 = 0 ;
23251 PyObject * obj0 = 0 ;
23252 PyObject * obj1 = 0 ;
23253 char * kwnames[] = {
23254 (char *) "self",(char *) "rect", NULL
23255 };
23256
23257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23259 if (!SWIG_IsOK(res1)) {
23260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23261 }
23262 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23263 {
23264 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23265 if (!SWIG_IsOK(res2)) {
23266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23267 }
23268 if (!argp2) {
23269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23270 } else {
23271 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23272 arg2 = *temp;
23273 if (SWIG_IsNewObj(res2)) delete temp;
23274 }
23275 }
23276 {
23277 PyThreadState* __tstate = wxPyBeginAllowThreads();
23278 (arg1)->SetRect(arg2);
23279 wxPyEndAllowThreads(__tstate);
23280 if (PyErr_Occurred()) SWIG_fail;
23281 }
23282 resultobj = SWIG_Py_Void();
23283 return resultobj;
23284 fail:
23285 return NULL;
23286 }
23287
23288
23289 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23290 PyObject *resultobj = 0;
23291 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23292 wxSize arg2 ;
23293 void *argp1 = 0 ;
23294 int res1 = 0 ;
23295 void *argp2 ;
23296 int res2 = 0 ;
23297 PyObject * obj0 = 0 ;
23298 PyObject * obj1 = 0 ;
23299 char * kwnames[] = {
23300 (char *) "self",(char *) "size", NULL
23301 };
23302
23303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23305 if (!SWIG_IsOK(res1)) {
23306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23307 }
23308 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23309 {
23310 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23311 if (!SWIG_IsOK(res2)) {
23312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23313 }
23314 if (!argp2) {
23315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23316 } else {
23317 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23318 arg2 = *temp;
23319 if (SWIG_IsNewObj(res2)) delete temp;
23320 }
23321 }
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 wxSizeEvent_SetSize(arg1,arg2);
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 resultobj = SWIG_Py_Void();
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23336 PyObject *resultobj = 0;
23337 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23338 wxSize *arg2 = (wxSize *) 0 ;
23339 void *argp1 = 0 ;
23340 int res1 = 0 ;
23341 void *argp2 = 0 ;
23342 int res2 = 0 ;
23343 PyObject *swig_obj[2] ;
23344
23345 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23347 if (!SWIG_IsOK(res1)) {
23348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23349 }
23350 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23351 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23352 if (!SWIG_IsOK(res2)) {
23353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23354 }
23355 arg2 = reinterpret_cast< wxSize * >(argp2);
23356 if (arg1) (arg1)->m_size = *arg2;
23357
23358 resultobj = SWIG_Py_Void();
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23366 PyObject *resultobj = 0;
23367 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23368 wxSize *result = 0 ;
23369 void *argp1 = 0 ;
23370 int res1 = 0 ;
23371 PyObject *swig_obj[1] ;
23372
23373 if (!args) SWIG_fail;
23374 swig_obj[0] = args;
23375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23376 if (!SWIG_IsOK(res1)) {
23377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23378 }
23379 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23380 result = (wxSize *)& ((arg1)->m_size);
23381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23389 PyObject *resultobj = 0;
23390 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23391 wxRect *arg2 = (wxRect *) 0 ;
23392 void *argp1 = 0 ;
23393 int res1 = 0 ;
23394 void *argp2 = 0 ;
23395 int res2 = 0 ;
23396 PyObject *swig_obj[2] ;
23397
23398 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23400 if (!SWIG_IsOK(res1)) {
23401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23402 }
23403 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23404 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23405 if (!SWIG_IsOK(res2)) {
23406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23407 }
23408 arg2 = reinterpret_cast< wxRect * >(argp2);
23409 if (arg1) (arg1)->m_rect = *arg2;
23410
23411 resultobj = SWIG_Py_Void();
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23419 PyObject *resultobj = 0;
23420 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23421 wxRect *result = 0 ;
23422 void *argp1 = 0 ;
23423 int res1 = 0 ;
23424 PyObject *swig_obj[1] ;
23425
23426 if (!args) SWIG_fail;
23427 swig_obj[0] = args;
23428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23429 if (!SWIG_IsOK(res1)) {
23430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23431 }
23432 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23433 result = (wxRect *)& ((arg1)->m_rect);
23434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *obj;
23443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23444 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23445 return SWIG_Py_Void();
23446 }
23447
23448 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23449 return SWIG_Python_InitShadowInstance(args);
23450 }
23451
23452 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23453 PyObject *resultobj = 0;
23454 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23455 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23456 int arg2 = (int) 0 ;
23457 wxMoveEvent *result = 0 ;
23458 wxPoint temp1 ;
23459 int val2 ;
23460 int ecode2 = 0 ;
23461 PyObject * obj0 = 0 ;
23462 PyObject * obj1 = 0 ;
23463 char * kwnames[] = {
23464 (char *) "pos",(char *) "winid", NULL
23465 };
23466
23467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23468 if (obj0) {
23469 {
23470 arg1 = &temp1;
23471 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23472 }
23473 }
23474 if (obj1) {
23475 ecode2 = SWIG_AsVal_int(obj1, &val2);
23476 if (!SWIG_IsOK(ecode2)) {
23477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23478 }
23479 arg2 = static_cast< int >(val2);
23480 }
23481 {
23482 PyThreadState* __tstate = wxPyBeginAllowThreads();
23483 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23484 wxPyEndAllowThreads(__tstate);
23485 if (PyErr_Occurred()) SWIG_fail;
23486 }
23487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *resultobj = 0;
23496 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23497 wxPoint result;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 PyObject *swig_obj[1] ;
23501
23502 if (!args) SWIG_fail;
23503 swig_obj[0] = args;
23504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23505 if (!SWIG_IsOK(res1)) {
23506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23507 }
23508 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = ((wxMoveEvent const *)arg1)->GetPosition();
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23516 return resultobj;
23517 fail:
23518 return NULL;
23519 }
23520
23521
23522 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23523 PyObject *resultobj = 0;
23524 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23525 wxRect result;
23526 void *argp1 = 0 ;
23527 int res1 = 0 ;
23528 PyObject *swig_obj[1] ;
23529
23530 if (!args) SWIG_fail;
23531 swig_obj[0] = args;
23532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23533 if (!SWIG_IsOK(res1)) {
23534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23535 }
23536 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23537 {
23538 PyThreadState* __tstate = wxPyBeginAllowThreads();
23539 result = ((wxMoveEvent const *)arg1)->GetRect();
23540 wxPyEndAllowThreads(__tstate);
23541 if (PyErr_Occurred()) SWIG_fail;
23542 }
23543 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23544 return resultobj;
23545 fail:
23546 return NULL;
23547 }
23548
23549
23550 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj = 0;
23552 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23553 wxRect *arg2 = 0 ;
23554 void *argp1 = 0 ;
23555 int res1 = 0 ;
23556 wxRect temp2 ;
23557 PyObject * obj0 = 0 ;
23558 PyObject * obj1 = 0 ;
23559 char * kwnames[] = {
23560 (char *) "self",(char *) "rect", NULL
23561 };
23562
23563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23565 if (!SWIG_IsOK(res1)) {
23566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23567 }
23568 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23569 {
23570 arg2 = &temp2;
23571 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23572 }
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 (arg1)->SetRect((wxRect const &)*arg2);
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 resultobj = SWIG_Py_Void();
23580 return resultobj;
23581 fail:
23582 return NULL;
23583 }
23584
23585
23586 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23587 PyObject *resultobj = 0;
23588 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23589 wxPoint *arg2 = 0 ;
23590 void *argp1 = 0 ;
23591 int res1 = 0 ;
23592 wxPoint temp2 ;
23593 PyObject * obj0 = 0 ;
23594 PyObject * obj1 = 0 ;
23595 char * kwnames[] = {
23596 (char *) "self",(char *) "pos", NULL
23597 };
23598
23599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23601 if (!SWIG_IsOK(res1)) {
23602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23603 }
23604 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23605 {
23606 arg2 = &temp2;
23607 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23608 }
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 (arg1)->SetPosition((wxPoint const &)*arg2);
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 resultobj = SWIG_Py_Void();
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23623 PyObject *obj;
23624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23625 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23626 return SWIG_Py_Void();
23627 }
23628
23629 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23630 return SWIG_Python_InitShadowInstance(args);
23631 }
23632
23633 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23634 PyObject *resultobj = 0;
23635 int arg1 = (int) 0 ;
23636 wxPaintEvent *result = 0 ;
23637 int val1 ;
23638 int ecode1 = 0 ;
23639 PyObject * obj0 = 0 ;
23640 char * kwnames[] = {
23641 (char *) "Id", NULL
23642 };
23643
23644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23645 if (obj0) {
23646 ecode1 = SWIG_AsVal_int(obj0, &val1);
23647 if (!SWIG_IsOK(ecode1)) {
23648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23649 }
23650 arg1 = static_cast< int >(val1);
23651 }
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 PyObject *obj;
23667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23668 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23669 return SWIG_Py_Void();
23670 }
23671
23672 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23673 return SWIG_Python_InitShadowInstance(args);
23674 }
23675
23676 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23677 PyObject *resultobj = 0;
23678 int arg1 = (int) 0 ;
23679 wxNcPaintEvent *result = 0 ;
23680 int val1 ;
23681 int ecode1 = 0 ;
23682 PyObject * obj0 = 0 ;
23683 char * kwnames[] = {
23684 (char *) "winid", NULL
23685 };
23686
23687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23688 if (obj0) {
23689 ecode1 = SWIG_AsVal_int(obj0, &val1);
23690 if (!SWIG_IsOK(ecode1)) {
23691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23692 }
23693 arg1 = static_cast< int >(val1);
23694 }
23695 {
23696 PyThreadState* __tstate = wxPyBeginAllowThreads();
23697 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23698 wxPyEndAllowThreads(__tstate);
23699 if (PyErr_Occurred()) SWIG_fail;
23700 }
23701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23702 return resultobj;
23703 fail:
23704 return NULL;
23705 }
23706
23707
23708 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23709 PyObject *obj;
23710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23711 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23712 return SWIG_Py_Void();
23713 }
23714
23715 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23716 return SWIG_Python_InitShadowInstance(args);
23717 }
23718
23719 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj = 0;
23721 int arg1 = (int) 0 ;
23722 wxDC *arg2 = (wxDC *) NULL ;
23723 wxEraseEvent *result = 0 ;
23724 int val1 ;
23725 int ecode1 = 0 ;
23726 void *argp2 = 0 ;
23727 int res2 = 0 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 char * kwnames[] = {
23731 (char *) "Id",(char *) "dc", NULL
23732 };
23733
23734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23735 if (obj0) {
23736 ecode1 = SWIG_AsVal_int(obj0, &val1);
23737 if (!SWIG_IsOK(ecode1)) {
23738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23739 }
23740 arg1 = static_cast< int >(val1);
23741 }
23742 if (obj1) {
23743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23744 if (!SWIG_IsOK(res2)) {
23745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23746 }
23747 arg2 = reinterpret_cast< wxDC * >(argp2);
23748 }
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23763 PyObject *resultobj = 0;
23764 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23765 wxDC *result = 0 ;
23766 void *argp1 = 0 ;
23767 int res1 = 0 ;
23768 PyObject *swig_obj[1] ;
23769
23770 if (!args) SWIG_fail;
23771 swig_obj[0] = args;
23772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23773 if (!SWIG_IsOK(res1)) {
23774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23775 }
23776 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 {
23784 resultobj = wxPyMake_wxObject(result, (bool)0);
23785 }
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23793 PyObject *obj;
23794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23795 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23796 return SWIG_Py_Void();
23797 }
23798
23799 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 return SWIG_Python_InitShadowInstance(args);
23801 }
23802
23803 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23804 PyObject *resultobj = 0;
23805 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23806 int arg2 = (int) 0 ;
23807 wxFocusEvent *result = 0 ;
23808 int val1 ;
23809 int ecode1 = 0 ;
23810 int val2 ;
23811 int ecode2 = 0 ;
23812 PyObject * obj0 = 0 ;
23813 PyObject * obj1 = 0 ;
23814 char * kwnames[] = {
23815 (char *) "type",(char *) "winid", NULL
23816 };
23817
23818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23819 if (obj0) {
23820 ecode1 = SWIG_AsVal_int(obj0, &val1);
23821 if (!SWIG_IsOK(ecode1)) {
23822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23823 }
23824 arg1 = static_cast< wxEventType >(val1);
23825 }
23826 if (obj1) {
23827 ecode2 = SWIG_AsVal_int(obj1, &val2);
23828 if (!SWIG_IsOK(ecode2)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23830 }
23831 arg2 = static_cast< int >(val2);
23832 }
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23836 wxPyEndAllowThreads(__tstate);
23837 if (PyErr_Occurred()) SWIG_fail;
23838 }
23839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23840 return resultobj;
23841 fail:
23842 return NULL;
23843 }
23844
23845
23846 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23847 PyObject *resultobj = 0;
23848 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23849 wxWindow *result = 0 ;
23850 void *argp1 = 0 ;
23851 int res1 = 0 ;
23852 PyObject *swig_obj[1] ;
23853
23854 if (!args) SWIG_fail;
23855 swig_obj[0] = args;
23856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23857 if (!SWIG_IsOK(res1)) {
23858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23859 }
23860 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23861 {
23862 PyThreadState* __tstate = wxPyBeginAllowThreads();
23863 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 {
23868 resultobj = wxPyMake_wxObject(result, (bool)0);
23869 }
23870 return resultobj;
23871 fail:
23872 return NULL;
23873 }
23874
23875
23876 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj = 0;
23878 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23879 wxWindow *arg2 = (wxWindow *) 0 ;
23880 void *argp1 = 0 ;
23881 int res1 = 0 ;
23882 void *argp2 = 0 ;
23883 int res2 = 0 ;
23884 PyObject * obj0 = 0 ;
23885 PyObject * obj1 = 0 ;
23886 char * kwnames[] = {
23887 (char *) "self",(char *) "win", NULL
23888 };
23889
23890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23892 if (!SWIG_IsOK(res1)) {
23893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23894 }
23895 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23897 if (!SWIG_IsOK(res2)) {
23898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23899 }
23900 arg2 = reinterpret_cast< wxWindow * >(argp2);
23901 {
23902 PyThreadState* __tstate = wxPyBeginAllowThreads();
23903 (arg1)->SetWindow(arg2);
23904 wxPyEndAllowThreads(__tstate);
23905 if (PyErr_Occurred()) SWIG_fail;
23906 }
23907 resultobj = SWIG_Py_Void();
23908 return resultobj;
23909 fail:
23910 return NULL;
23911 }
23912
23913
23914 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23915 PyObject *obj;
23916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23917 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23918 return SWIG_Py_Void();
23919 }
23920
23921 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23922 return SWIG_Python_InitShadowInstance(args);
23923 }
23924
23925 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23926 PyObject *resultobj = 0;
23927 wxWindow *arg1 = (wxWindow *) NULL ;
23928 wxChildFocusEvent *result = 0 ;
23929 void *argp1 = 0 ;
23930 int res1 = 0 ;
23931 PyObject * obj0 = 0 ;
23932 char * kwnames[] = {
23933 (char *) "win", NULL
23934 };
23935
23936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23937 if (obj0) {
23938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23939 if (!SWIG_IsOK(res1)) {
23940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23941 }
23942 arg1 = reinterpret_cast< wxWindow * >(argp1);
23943 }
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23947 wxPyEndAllowThreads(__tstate);
23948 if (PyErr_Occurred()) SWIG_fail;
23949 }
23950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23951 return resultobj;
23952 fail:
23953 return NULL;
23954 }
23955
23956
23957 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23958 PyObject *resultobj = 0;
23959 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23960 wxWindow *result = 0 ;
23961 void *argp1 = 0 ;
23962 int res1 = 0 ;
23963 PyObject *swig_obj[1] ;
23964
23965 if (!args) SWIG_fail;
23966 swig_obj[0] = args;
23967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23968 if (!SWIG_IsOK(res1)) {
23969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23970 }
23971 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23972 {
23973 PyThreadState* __tstate = wxPyBeginAllowThreads();
23974 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23975 wxPyEndAllowThreads(__tstate);
23976 if (PyErr_Occurred()) SWIG_fail;
23977 }
23978 {
23979 resultobj = wxPyMake_wxObject(result, (bool)0);
23980 }
23981 return resultobj;
23982 fail:
23983 return NULL;
23984 }
23985
23986
23987 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23988 PyObject *obj;
23989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23990 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23991 return SWIG_Py_Void();
23992 }
23993
23994 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23995 return SWIG_Python_InitShadowInstance(args);
23996 }
23997
23998 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj = 0;
24000 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24001 bool arg2 = (bool) true ;
24002 int arg3 = (int) 0 ;
24003 wxActivateEvent *result = 0 ;
24004 int val1 ;
24005 int ecode1 = 0 ;
24006 bool val2 ;
24007 int ecode2 = 0 ;
24008 int val3 ;
24009 int ecode3 = 0 ;
24010 PyObject * obj0 = 0 ;
24011 PyObject * obj1 = 0 ;
24012 PyObject * obj2 = 0 ;
24013 char * kwnames[] = {
24014 (char *) "type",(char *) "active",(char *) "Id", NULL
24015 };
24016
24017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24018 if (obj0) {
24019 ecode1 = SWIG_AsVal_int(obj0, &val1);
24020 if (!SWIG_IsOK(ecode1)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24022 }
24023 arg1 = static_cast< wxEventType >(val1);
24024 }
24025 if (obj1) {
24026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24027 if (!SWIG_IsOK(ecode2)) {
24028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24029 }
24030 arg2 = static_cast< bool >(val2);
24031 }
24032 if (obj2) {
24033 ecode3 = SWIG_AsVal_int(obj2, &val3);
24034 if (!SWIG_IsOK(ecode3)) {
24035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24036 }
24037 arg3 = static_cast< int >(val3);
24038 }
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24046 return resultobj;
24047 fail:
24048 return NULL;
24049 }
24050
24051
24052 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24053 PyObject *resultobj = 0;
24054 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24055 bool result;
24056 void *argp1 = 0 ;
24057 int res1 = 0 ;
24058 PyObject *swig_obj[1] ;
24059
24060 if (!args) SWIG_fail;
24061 swig_obj[0] = args;
24062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24063 if (!SWIG_IsOK(res1)) {
24064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24065 }
24066 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24067 {
24068 PyThreadState* __tstate = wxPyBeginAllowThreads();
24069 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24070 wxPyEndAllowThreads(__tstate);
24071 if (PyErr_Occurred()) SWIG_fail;
24072 }
24073 {
24074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24075 }
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24083 PyObject *obj;
24084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24085 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24086 return SWIG_Py_Void();
24087 }
24088
24089 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24090 return SWIG_Python_InitShadowInstance(args);
24091 }
24092
24093 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24094 PyObject *resultobj = 0;
24095 int arg1 = (int) 0 ;
24096 wxInitDialogEvent *result = 0 ;
24097 int val1 ;
24098 int ecode1 = 0 ;
24099 PyObject * obj0 = 0 ;
24100 char * kwnames[] = {
24101 (char *) "Id", NULL
24102 };
24103
24104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24105 if (obj0) {
24106 ecode1 = SWIG_AsVal_int(obj0, &val1);
24107 if (!SWIG_IsOK(ecode1)) {
24108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24109 }
24110 arg1 = static_cast< int >(val1);
24111 }
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 PyObject *obj;
24127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24128 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24129 return SWIG_Py_Void();
24130 }
24131
24132 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24133 return SWIG_Python_InitShadowInstance(args);
24134 }
24135
24136 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj = 0;
24138 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24139 int arg2 = (int) 0 ;
24140 wxMenu *arg3 = (wxMenu *) NULL ;
24141 wxMenuEvent *result = 0 ;
24142 int val1 ;
24143 int ecode1 = 0 ;
24144 int val2 ;
24145 int ecode2 = 0 ;
24146 void *argp3 = 0 ;
24147 int res3 = 0 ;
24148 PyObject * obj0 = 0 ;
24149 PyObject * obj1 = 0 ;
24150 PyObject * obj2 = 0 ;
24151 char * kwnames[] = {
24152 (char *) "type",(char *) "winid",(char *) "menu", NULL
24153 };
24154
24155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24156 if (obj0) {
24157 ecode1 = SWIG_AsVal_int(obj0, &val1);
24158 if (!SWIG_IsOK(ecode1)) {
24159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24160 }
24161 arg1 = static_cast< wxEventType >(val1);
24162 }
24163 if (obj1) {
24164 ecode2 = SWIG_AsVal_int(obj1, &val2);
24165 if (!SWIG_IsOK(ecode2)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24167 }
24168 arg2 = static_cast< int >(val2);
24169 }
24170 if (obj2) {
24171 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24172 if (!SWIG_IsOK(res3)) {
24173 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24174 }
24175 arg3 = reinterpret_cast< wxMenu * >(argp3);
24176 }
24177 {
24178 PyThreadState* __tstate = wxPyBeginAllowThreads();
24179 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24191 PyObject *resultobj = 0;
24192 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24193 int result;
24194 void *argp1 = 0 ;
24195 int res1 = 0 ;
24196 PyObject *swig_obj[1] ;
24197
24198 if (!args) SWIG_fail;
24199 swig_obj[0] = args;
24200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24201 if (!SWIG_IsOK(res1)) {
24202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24203 }
24204 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24205 {
24206 PyThreadState* __tstate = wxPyBeginAllowThreads();
24207 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24208 wxPyEndAllowThreads(__tstate);
24209 if (PyErr_Occurred()) SWIG_fail;
24210 }
24211 resultobj = SWIG_From_int(static_cast< int >(result));
24212 return resultobj;
24213 fail:
24214 return NULL;
24215 }
24216
24217
24218 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24219 PyObject *resultobj = 0;
24220 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24221 bool result;
24222 void *argp1 = 0 ;
24223 int res1 = 0 ;
24224 PyObject *swig_obj[1] ;
24225
24226 if (!args) SWIG_fail;
24227 swig_obj[0] = args;
24228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24229 if (!SWIG_IsOK(res1)) {
24230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24231 }
24232 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24233 {
24234 PyThreadState* __tstate = wxPyBeginAllowThreads();
24235 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24236 wxPyEndAllowThreads(__tstate);
24237 if (PyErr_Occurred()) SWIG_fail;
24238 }
24239 {
24240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24241 }
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24249 PyObject *resultobj = 0;
24250 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24251 wxMenu *result = 0 ;
24252 void *argp1 = 0 ;
24253 int res1 = 0 ;
24254 PyObject *swig_obj[1] ;
24255
24256 if (!args) SWIG_fail;
24257 swig_obj[0] = args;
24258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24261 }
24262 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24266 wxPyEndAllowThreads(__tstate);
24267 if (PyErr_Occurred()) SWIG_fail;
24268 }
24269 {
24270 resultobj = wxPyMake_wxObject(result, (bool)0);
24271 }
24272 return resultobj;
24273 fail:
24274 return NULL;
24275 }
24276
24277
24278 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24279 PyObject *obj;
24280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24281 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24282 return SWIG_Py_Void();
24283 }
24284
24285 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24286 return SWIG_Python_InitShadowInstance(args);
24287 }
24288
24289 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24290 PyObject *resultobj = 0;
24291 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24292 int arg2 = (int) 0 ;
24293 wxCloseEvent *result = 0 ;
24294 int val1 ;
24295 int ecode1 = 0 ;
24296 int val2 ;
24297 int ecode2 = 0 ;
24298 PyObject * obj0 = 0 ;
24299 PyObject * obj1 = 0 ;
24300 char * kwnames[] = {
24301 (char *) "type",(char *) "winid", NULL
24302 };
24303
24304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24305 if (obj0) {
24306 ecode1 = SWIG_AsVal_int(obj0, &val1);
24307 if (!SWIG_IsOK(ecode1)) {
24308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24309 }
24310 arg1 = static_cast< wxEventType >(val1);
24311 }
24312 if (obj1) {
24313 ecode2 = SWIG_AsVal_int(obj1, &val2);
24314 if (!SWIG_IsOK(ecode2)) {
24315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24316 }
24317 arg2 = static_cast< int >(val2);
24318 }
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24322 wxPyEndAllowThreads(__tstate);
24323 if (PyErr_Occurred()) SWIG_fail;
24324 }
24325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24326 return resultobj;
24327 fail:
24328 return NULL;
24329 }
24330
24331
24332 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24333 PyObject *resultobj = 0;
24334 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24335 bool arg2 ;
24336 void *argp1 = 0 ;
24337 int res1 = 0 ;
24338 bool val2 ;
24339 int ecode2 = 0 ;
24340 PyObject * obj0 = 0 ;
24341 PyObject * obj1 = 0 ;
24342 char * kwnames[] = {
24343 (char *) "self",(char *) "logOff", NULL
24344 };
24345
24346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24348 if (!SWIG_IsOK(res1)) {
24349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24350 }
24351 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24353 if (!SWIG_IsOK(ecode2)) {
24354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24355 }
24356 arg2 = static_cast< bool >(val2);
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 (arg1)->SetLoggingOff(arg2);
24360 wxPyEndAllowThreads(__tstate);
24361 if (PyErr_Occurred()) SWIG_fail;
24362 }
24363 resultobj = SWIG_Py_Void();
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24371 PyObject *resultobj = 0;
24372 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24373 bool result;
24374 void *argp1 = 0 ;
24375 int res1 = 0 ;
24376 PyObject *swig_obj[1] ;
24377
24378 if (!args) SWIG_fail;
24379 swig_obj[0] = args;
24380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24381 if (!SWIG_IsOK(res1)) {
24382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24383 }
24384 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24388 wxPyEndAllowThreads(__tstate);
24389 if (PyErr_Occurred()) SWIG_fail;
24390 }
24391 {
24392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24393 }
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj = 0;
24402 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24403 bool arg2 = (bool) true ;
24404 void *argp1 = 0 ;
24405 int res1 = 0 ;
24406 bool val2 ;
24407 int ecode2 = 0 ;
24408 PyObject * obj0 = 0 ;
24409 PyObject * obj1 = 0 ;
24410 char * kwnames[] = {
24411 (char *) "self",(char *) "veto", NULL
24412 };
24413
24414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24416 if (!SWIG_IsOK(res1)) {
24417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24418 }
24419 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24420 if (obj1) {
24421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24422 if (!SWIG_IsOK(ecode2)) {
24423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24424 }
24425 arg2 = static_cast< bool >(val2);
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 (arg1)->Veto(arg2);
24430 wxPyEndAllowThreads(__tstate);
24431 if (PyErr_Occurred()) SWIG_fail;
24432 }
24433 resultobj = SWIG_Py_Void();
24434 return resultobj;
24435 fail:
24436 return NULL;
24437 }
24438
24439
24440 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 PyObject *resultobj = 0;
24442 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24443 bool result;
24444 void *argp1 = 0 ;
24445 int res1 = 0 ;
24446 PyObject *swig_obj[1] ;
24447
24448 if (!args) SWIG_fail;
24449 swig_obj[0] = args;
24450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24453 }
24454 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj = 0;
24472 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24473 bool arg2 ;
24474 void *argp1 = 0 ;
24475 int res1 = 0 ;
24476 bool val2 ;
24477 int ecode2 = 0 ;
24478 PyObject * obj0 = 0 ;
24479 PyObject * obj1 = 0 ;
24480 char * kwnames[] = {
24481 (char *) "self",(char *) "canVeto", NULL
24482 };
24483
24484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24490 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24491 if (!SWIG_IsOK(ecode2)) {
24492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24493 }
24494 arg2 = static_cast< bool >(val2);
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 (arg1)->SetCanVeto(arg2);
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_Py_Void();
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24509 PyObject *resultobj = 0;
24510 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24511 bool result;
24512 void *argp1 = 0 ;
24513 int res1 = 0 ;
24514 PyObject *swig_obj[1] ;
24515
24516 if (!args) SWIG_fail;
24517 swig_obj[0] = args;
24518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24519 if (!SWIG_IsOK(res1)) {
24520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24521 }
24522 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 PyObject *obj;
24540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24541 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24542 return SWIG_Py_Void();
24543 }
24544
24545 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24546 return SWIG_Python_InitShadowInstance(args);
24547 }
24548
24549 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = 0;
24551 int arg1 = (int) 0 ;
24552 bool arg2 = (bool) false ;
24553 wxShowEvent *result = 0 ;
24554 int val1 ;
24555 int ecode1 = 0 ;
24556 bool val2 ;
24557 int ecode2 = 0 ;
24558 PyObject * obj0 = 0 ;
24559 PyObject * obj1 = 0 ;
24560 char * kwnames[] = {
24561 (char *) "winid",(char *) "show", NULL
24562 };
24563
24564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24565 if (obj0) {
24566 ecode1 = SWIG_AsVal_int(obj0, &val1);
24567 if (!SWIG_IsOK(ecode1)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24569 }
24570 arg1 = static_cast< int >(val1);
24571 }
24572 if (obj1) {
24573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24574 if (!SWIG_IsOK(ecode2)) {
24575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24576 }
24577 arg2 = static_cast< bool >(val2);
24578 }
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24593 PyObject *resultobj = 0;
24594 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24595 bool arg2 ;
24596 void *argp1 = 0 ;
24597 int res1 = 0 ;
24598 bool val2 ;
24599 int ecode2 = 0 ;
24600 PyObject * obj0 = 0 ;
24601 PyObject * obj1 = 0 ;
24602 char * kwnames[] = {
24603 (char *) "self",(char *) "show", NULL
24604 };
24605
24606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24608 if (!SWIG_IsOK(res1)) {
24609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24610 }
24611 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24612 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24613 if (!SWIG_IsOK(ecode2)) {
24614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24615 }
24616 arg2 = static_cast< bool >(val2);
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 (arg1)->SetShow(arg2);
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 resultobj = SWIG_Py_Void();
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *resultobj = 0;
24632 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24633 bool result;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 PyObject *swig_obj[1] ;
24637
24638 if (!args) SWIG_fail;
24639 swig_obj[0] = args;
24640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24641 if (!SWIG_IsOK(res1)) {
24642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24643 }
24644 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 {
24652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24653 }
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24661 PyObject *obj;
24662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24663 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24664 return SWIG_Py_Void();
24665 }
24666
24667 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24668 return SWIG_Python_InitShadowInstance(args);
24669 }
24670
24671 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj = 0;
24673 int arg1 = (int) 0 ;
24674 bool arg2 = (bool) true ;
24675 wxIconizeEvent *result = 0 ;
24676 int val1 ;
24677 int ecode1 = 0 ;
24678 bool val2 ;
24679 int ecode2 = 0 ;
24680 PyObject * obj0 = 0 ;
24681 PyObject * obj1 = 0 ;
24682 char * kwnames[] = {
24683 (char *) "id",(char *) "iconized", NULL
24684 };
24685
24686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24687 if (obj0) {
24688 ecode1 = SWIG_AsVal_int(obj0, &val1);
24689 if (!SWIG_IsOK(ecode1)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24691 }
24692 arg1 = static_cast< int >(val1);
24693 }
24694 if (obj1) {
24695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24696 if (!SWIG_IsOK(ecode2)) {
24697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24698 }
24699 arg2 = static_cast< bool >(val2);
24700 }
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24715 PyObject *resultobj = 0;
24716 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24717 bool result;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 PyObject *swig_obj[1] ;
24721
24722 if (!args) SWIG_fail;
24723 swig_obj[0] = args;
24724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24725 if (!SWIG_IsOK(res1)) {
24726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24727 }
24728 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24729 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 result = (bool)(arg1)->Iconized();
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 {
24736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24745 PyObject *obj;
24746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24747 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24748 return SWIG_Py_Void();
24749 }
24750
24751 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 return SWIG_Python_InitShadowInstance(args);
24753 }
24754
24755 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = 0;
24757 int arg1 = (int) 0 ;
24758 wxMaximizeEvent *result = 0 ;
24759 int val1 ;
24760 int ecode1 = 0 ;
24761 PyObject * obj0 = 0 ;
24762 char * kwnames[] = {
24763 (char *) "id", NULL
24764 };
24765
24766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24767 if (obj0) {
24768 ecode1 = SWIG_AsVal_int(obj0, &val1);
24769 if (!SWIG_IsOK(ecode1)) {
24770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24771 }
24772 arg1 = static_cast< int >(val1);
24773 }
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24777 wxPyEndAllowThreads(__tstate);
24778 if (PyErr_Occurred()) SWIG_fail;
24779 }
24780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24788 PyObject *obj;
24789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24790 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24791 return SWIG_Py_Void();
24792 }
24793
24794 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24795 return SWIG_Python_InitShadowInstance(args);
24796 }
24797
24798 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24799 PyObject *resultobj = 0;
24800 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24801 wxPoint result;
24802 void *argp1 = 0 ;
24803 int res1 = 0 ;
24804 PyObject *swig_obj[1] ;
24805
24806 if (!args) SWIG_fail;
24807 swig_obj[0] = args;
24808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24809 if (!SWIG_IsOK(res1)) {
24810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24811 }
24812 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24813 {
24814 PyThreadState* __tstate = wxPyBeginAllowThreads();
24815 result = (arg1)->GetPosition();
24816 wxPyEndAllowThreads(__tstate);
24817 if (PyErr_Occurred()) SWIG_fail;
24818 }
24819 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24820 return resultobj;
24821 fail:
24822 return NULL;
24823 }
24824
24825
24826 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 PyObject *resultobj = 0;
24828 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24829 int result;
24830 void *argp1 = 0 ;
24831 int res1 = 0 ;
24832 PyObject *swig_obj[1] ;
24833
24834 if (!args) SWIG_fail;
24835 swig_obj[0] = args;
24836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24837 if (!SWIG_IsOK(res1)) {
24838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24839 }
24840 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 result = (int)(arg1)->GetNumberOfFiles();
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_From_int(static_cast< int >(result));
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24855 PyObject *resultobj = 0;
24856 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24857 PyObject *result = 0 ;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 PyObject *swig_obj[1] ;
24861
24862 if (!args) SWIG_fail;
24863 swig_obj[0] = args;
24864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24867 }
24868 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24869 {
24870 PyThreadState* __tstate = wxPyBeginAllowThreads();
24871 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 resultobj = result;
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24883 PyObject *obj;
24884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24885 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24886 return SWIG_Py_Void();
24887 }
24888
24889 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj = 0;
24891 int arg1 = (int) 0 ;
24892 wxUpdateUIEvent *result = 0 ;
24893 int val1 ;
24894 int ecode1 = 0 ;
24895 PyObject * obj0 = 0 ;
24896 char * kwnames[] = {
24897 (char *) "commandId", NULL
24898 };
24899
24900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24901 if (obj0) {
24902 ecode1 = SWIG_AsVal_int(obj0, &val1);
24903 if (!SWIG_IsOK(ecode1)) {
24904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24905 }
24906 arg1 = static_cast< int >(val1);
24907 }
24908 {
24909 PyThreadState* __tstate = wxPyBeginAllowThreads();
24910 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24911 wxPyEndAllowThreads(__tstate);
24912 if (PyErr_Occurred()) SWIG_fail;
24913 }
24914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24922 PyObject *resultobj = 0;
24923 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24924 bool result;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 PyObject *swig_obj[1] ;
24928
24929 if (!args) SWIG_fail;
24930 swig_obj[0] = args;
24931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24932 if (!SWIG_IsOK(res1)) {
24933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24934 }
24935 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24944 }
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24952 PyObject *resultobj = 0;
24953 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24954 bool result;
24955 void *argp1 = 0 ;
24956 int res1 = 0 ;
24957 PyObject *swig_obj[1] ;
24958
24959 if (!args) SWIG_fail;
24960 swig_obj[0] = args;
24961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24962 if (!SWIG_IsOK(res1)) {
24963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24964 }
24965 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24966 {
24967 PyThreadState* __tstate = wxPyBeginAllowThreads();
24968 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24969 wxPyEndAllowThreads(__tstate);
24970 if (PyErr_Occurred()) SWIG_fail;
24971 }
24972 {
24973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24982 PyObject *resultobj = 0;
24983 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24984 bool result;
24985 void *argp1 = 0 ;
24986 int res1 = 0 ;
24987 PyObject *swig_obj[1] ;
24988
24989 if (!args) SWIG_fail;
24990 swig_obj[0] = args;
24991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24992 if (!SWIG_IsOK(res1)) {
24993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24994 }
24995 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 {
25003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25004 }
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25012 PyObject *resultobj = 0;
25013 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25014 wxString result;
25015 void *argp1 = 0 ;
25016 int res1 = 0 ;
25017 PyObject *swig_obj[1] ;
25018
25019 if (!args) SWIG_fail;
25020 swig_obj[0] = args;
25021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25024 }
25025 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25029 wxPyEndAllowThreads(__tstate);
25030 if (PyErr_Occurred()) SWIG_fail;
25031 }
25032 {
25033 #if wxUSE_UNICODE
25034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25035 #else
25036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25037 #endif
25038 }
25039 return resultobj;
25040 fail:
25041 return NULL;
25042 }
25043
25044
25045 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25046 PyObject *resultobj = 0;
25047 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25048 bool result;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 PyObject *swig_obj[1] ;
25052
25053 if (!args) SWIG_fail;
25054 swig_obj[0] = args;
25055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25056 if (!SWIG_IsOK(res1)) {
25057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25058 }
25059 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25068 }
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25076 PyObject *resultobj = 0;
25077 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25078 bool result;
25079 void *argp1 = 0 ;
25080 int res1 = 0 ;
25081 PyObject *swig_obj[1] ;
25082
25083 if (!args) SWIG_fail;
25084 swig_obj[0] = args;
25085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25086 if (!SWIG_IsOK(res1)) {
25087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25088 }
25089 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25106 PyObject *resultobj = 0;
25107 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25108 bool result;
25109 void *argp1 = 0 ;
25110 int res1 = 0 ;
25111 PyObject *swig_obj[1] ;
25112
25113 if (!args) SWIG_fail;
25114 swig_obj[0] = args;
25115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25116 if (!SWIG_IsOK(res1)) {
25117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25118 }
25119 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25120 {
25121 PyThreadState* __tstate = wxPyBeginAllowThreads();
25122 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 {
25127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25128 }
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25136 PyObject *resultobj = 0;
25137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25138 bool result;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 PyObject *swig_obj[1] ;
25142
25143 if (!args) SWIG_fail;
25144 swig_obj[0] = args;
25145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25146 if (!SWIG_IsOK(res1)) {
25147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25148 }
25149 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 {
25157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25158 }
25159 return resultobj;
25160 fail:
25161 return NULL;
25162 }
25163
25164
25165 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25166 PyObject *resultobj = 0;
25167 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25168 bool arg2 ;
25169 void *argp1 = 0 ;
25170 int res1 = 0 ;
25171 bool val2 ;
25172 int ecode2 = 0 ;
25173 PyObject * obj0 = 0 ;
25174 PyObject * obj1 = 0 ;
25175 char * kwnames[] = {
25176 (char *) "self",(char *) "check", NULL
25177 };
25178
25179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25181 if (!SWIG_IsOK(res1)) {
25182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25183 }
25184 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25186 if (!SWIG_IsOK(ecode2)) {
25187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25188 }
25189 arg2 = static_cast< bool >(val2);
25190 {
25191 PyThreadState* __tstate = wxPyBeginAllowThreads();
25192 (arg1)->Check(arg2);
25193 wxPyEndAllowThreads(__tstate);
25194 if (PyErr_Occurred()) SWIG_fail;
25195 }
25196 resultobj = SWIG_Py_Void();
25197 return resultobj;
25198 fail:
25199 return NULL;
25200 }
25201
25202
25203 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25204 PyObject *resultobj = 0;
25205 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25206 bool arg2 ;
25207 void *argp1 = 0 ;
25208 int res1 = 0 ;
25209 bool val2 ;
25210 int ecode2 = 0 ;
25211 PyObject * obj0 = 0 ;
25212 PyObject * obj1 = 0 ;
25213 char * kwnames[] = {
25214 (char *) "self",(char *) "enable", NULL
25215 };
25216
25217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25219 if (!SWIG_IsOK(res1)) {
25220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25221 }
25222 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25224 if (!SWIG_IsOK(ecode2)) {
25225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25226 }
25227 arg2 = static_cast< bool >(val2);
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 (arg1)->Enable(arg2);
25231 wxPyEndAllowThreads(__tstate);
25232 if (PyErr_Occurred()) SWIG_fail;
25233 }
25234 resultobj = SWIG_Py_Void();
25235 return resultobj;
25236 fail:
25237 return NULL;
25238 }
25239
25240
25241 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25242 PyObject *resultobj = 0;
25243 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25244 bool arg2 ;
25245 void *argp1 = 0 ;
25246 int res1 = 0 ;
25247 bool val2 ;
25248 int ecode2 = 0 ;
25249 PyObject * obj0 = 0 ;
25250 PyObject * obj1 = 0 ;
25251 char * kwnames[] = {
25252 (char *) "self",(char *) "show", NULL
25253 };
25254
25255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25257 if (!SWIG_IsOK(res1)) {
25258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25259 }
25260 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25262 if (!SWIG_IsOK(ecode2)) {
25263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25264 }
25265 arg2 = static_cast< bool >(val2);
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->Show(arg2);
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 resultobj = SWIG_Py_Void();
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25280 PyObject *resultobj = 0;
25281 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25282 wxString *arg2 = 0 ;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 bool temp2 = false ;
25286 PyObject * obj0 = 0 ;
25287 PyObject * obj1 = 0 ;
25288 char * kwnames[] = {
25289 (char *) "self",(char *) "text", NULL
25290 };
25291
25292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25294 if (!SWIG_IsOK(res1)) {
25295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25296 }
25297 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25298 {
25299 arg2 = wxString_in_helper(obj1);
25300 if (arg2 == NULL) SWIG_fail;
25301 temp2 = true;
25302 }
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 (arg1)->SetText((wxString const &)*arg2);
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 resultobj = SWIG_Py_Void();
25310 {
25311 if (temp2)
25312 delete arg2;
25313 }
25314 return resultobj;
25315 fail:
25316 {
25317 if (temp2)
25318 delete arg2;
25319 }
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25325 PyObject *resultobj = 0;
25326 long arg1 ;
25327 long val1 ;
25328 int ecode1 = 0 ;
25329 PyObject * obj0 = 0 ;
25330 char * kwnames[] = {
25331 (char *) "updateInterval", NULL
25332 };
25333
25334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25335 ecode1 = SWIG_AsVal_long(obj0, &val1);
25336 if (!SWIG_IsOK(ecode1)) {
25337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25338 }
25339 arg1 = static_cast< long >(val1);
25340 {
25341 PyThreadState* __tstate = wxPyBeginAllowThreads();
25342 wxUpdateUIEvent::SetUpdateInterval(arg1);
25343 wxPyEndAllowThreads(__tstate);
25344 if (PyErr_Occurred()) SWIG_fail;
25345 }
25346 resultobj = SWIG_Py_Void();
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 PyObject *resultobj = 0;
25355 long result;
25356
25357 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25361 wxPyEndAllowThreads(__tstate);
25362 if (PyErr_Occurred()) SWIG_fail;
25363 }
25364 resultobj = SWIG_From_long(static_cast< long >(result));
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25372 PyObject *resultobj = 0;
25373 wxWindow *arg1 = (wxWindow *) 0 ;
25374 bool result;
25375 void *argp1 = 0 ;
25376 int res1 = 0 ;
25377 PyObject * obj0 = 0 ;
25378 char * kwnames[] = {
25379 (char *) "win", NULL
25380 };
25381
25382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25384 if (!SWIG_IsOK(res1)) {
25385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25386 }
25387 arg1 = reinterpret_cast< wxWindow * >(argp1);
25388 {
25389 PyThreadState* __tstate = wxPyBeginAllowThreads();
25390 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 {
25395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25396 }
25397 return resultobj;
25398 fail:
25399 return NULL;
25400 }
25401
25402
25403 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25404 PyObject *resultobj = 0;
25405
25406 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 wxUpdateUIEvent::ResetUpdateTime();
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 resultobj = SWIG_Py_Void();
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25421 PyObject *resultobj = 0;
25422 wxUpdateUIMode arg1 ;
25423 int val1 ;
25424 int ecode1 = 0 ;
25425 PyObject * obj0 = 0 ;
25426 char * kwnames[] = {
25427 (char *) "mode", NULL
25428 };
25429
25430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25431 ecode1 = SWIG_AsVal_int(obj0, &val1);
25432 if (!SWIG_IsOK(ecode1)) {
25433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25434 }
25435 arg1 = static_cast< wxUpdateUIMode >(val1);
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 wxUpdateUIEvent::SetMode(arg1);
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_Py_Void();
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *resultobj = 0;
25451 wxUpdateUIMode result;
25452
25453 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25454 {
25455 PyThreadState* __tstate = wxPyBeginAllowThreads();
25456 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25457 wxPyEndAllowThreads(__tstate);
25458 if (PyErr_Occurred()) SWIG_fail;
25459 }
25460 resultobj = SWIG_From_int(static_cast< int >(result));
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25468 PyObject *obj;
25469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25470 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25471 return SWIG_Py_Void();
25472 }
25473
25474 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25475 return SWIG_Python_InitShadowInstance(args);
25476 }
25477
25478 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25479 PyObject *resultobj = 0;
25480 wxSysColourChangedEvent *result = 0 ;
25481
25482 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25483 {
25484 PyThreadState* __tstate = wxPyBeginAllowThreads();
25485 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25497 PyObject *obj;
25498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25499 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25500 return SWIG_Py_Void();
25501 }
25502
25503 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 return SWIG_Python_InitShadowInstance(args);
25505 }
25506
25507 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25508 PyObject *resultobj = 0;
25509 int arg1 = (int) 0 ;
25510 wxWindow *arg2 = (wxWindow *) NULL ;
25511 wxMouseCaptureChangedEvent *result = 0 ;
25512 int val1 ;
25513 int ecode1 = 0 ;
25514 void *argp2 = 0 ;
25515 int res2 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 PyObject * obj1 = 0 ;
25518 char * kwnames[] = {
25519 (char *) "winid",(char *) "gainedCapture", NULL
25520 };
25521
25522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25523 if (obj0) {
25524 ecode1 = SWIG_AsVal_int(obj0, &val1);
25525 if (!SWIG_IsOK(ecode1)) {
25526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25527 }
25528 arg1 = static_cast< int >(val1);
25529 }
25530 if (obj1) {
25531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25532 if (!SWIG_IsOK(res2)) {
25533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25534 }
25535 arg2 = reinterpret_cast< wxWindow * >(argp2);
25536 }
25537 {
25538 PyThreadState* __tstate = wxPyBeginAllowThreads();
25539 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25540 wxPyEndAllowThreads(__tstate);
25541 if (PyErr_Occurred()) SWIG_fail;
25542 }
25543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25551 PyObject *resultobj = 0;
25552 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25553 wxWindow *result = 0 ;
25554 void *argp1 = 0 ;
25555 int res1 = 0 ;
25556 PyObject *swig_obj[1] ;
25557
25558 if (!args) SWIG_fail;
25559 swig_obj[0] = args;
25560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25563 }
25564 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25568 wxPyEndAllowThreads(__tstate);
25569 if (PyErr_Occurred()) SWIG_fail;
25570 }
25571 {
25572 resultobj = wxPyMake_wxObject(result, (bool)0);
25573 }
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25581 PyObject *obj;
25582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25583 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25584 return SWIG_Py_Void();
25585 }
25586
25587 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 return SWIG_Python_InitShadowInstance(args);
25589 }
25590
25591 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25592 PyObject *resultobj = 0;
25593 int arg1 = (int) 0 ;
25594 wxMouseCaptureLostEvent *result = 0 ;
25595 int val1 ;
25596 int ecode1 = 0 ;
25597 PyObject * obj0 = 0 ;
25598 char * kwnames[] = {
25599 (char *) "winid", NULL
25600 };
25601
25602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25603 if (obj0) {
25604 ecode1 = SWIG_AsVal_int(obj0, &val1);
25605 if (!SWIG_IsOK(ecode1)) {
25606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25607 }
25608 arg1 = static_cast< int >(val1);
25609 }
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25613 wxPyEndAllowThreads(__tstate);
25614 if (PyErr_Occurred()) SWIG_fail;
25615 }
25616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25624 PyObject *obj;
25625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25626 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25627 return SWIG_Py_Void();
25628 }
25629
25630 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25631 return SWIG_Python_InitShadowInstance(args);
25632 }
25633
25634 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25635 PyObject *resultobj = 0;
25636 wxDisplayChangedEvent *result = 0 ;
25637
25638 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25642 wxPyEndAllowThreads(__tstate);
25643 if (PyErr_Occurred()) SWIG_fail;
25644 }
25645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25646 return resultobj;
25647 fail:
25648 return NULL;
25649 }
25650
25651
25652 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25653 PyObject *obj;
25654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25655 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25656 return SWIG_Py_Void();
25657 }
25658
25659 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 return SWIG_Python_InitShadowInstance(args);
25661 }
25662
25663 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj = 0;
25665 int arg1 = (int) 0 ;
25666 wxPaletteChangedEvent *result = 0 ;
25667 int val1 ;
25668 int ecode1 = 0 ;
25669 PyObject * obj0 = 0 ;
25670 char * kwnames[] = {
25671 (char *) "id", NULL
25672 };
25673
25674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25675 if (obj0) {
25676 ecode1 = SWIG_AsVal_int(obj0, &val1);
25677 if (!SWIG_IsOK(ecode1)) {
25678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25679 }
25680 arg1 = static_cast< int >(val1);
25681 }
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj = 0;
25697 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25698 wxWindow *arg2 = (wxWindow *) 0 ;
25699 void *argp1 = 0 ;
25700 int res1 = 0 ;
25701 void *argp2 = 0 ;
25702 int res2 = 0 ;
25703 PyObject * obj0 = 0 ;
25704 PyObject * obj1 = 0 ;
25705 char * kwnames[] = {
25706 (char *) "self",(char *) "win", NULL
25707 };
25708
25709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25711 if (!SWIG_IsOK(res1)) {
25712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25713 }
25714 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25716 if (!SWIG_IsOK(res2)) {
25717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25718 }
25719 arg2 = reinterpret_cast< wxWindow * >(argp2);
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 (arg1)->SetChangedWindow(arg2);
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 resultobj = SWIG_Py_Void();
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25734 PyObject *resultobj = 0;
25735 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25736 wxWindow *result = 0 ;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 PyObject *swig_obj[1] ;
25740
25741 if (!args) SWIG_fail;
25742 swig_obj[0] = args;
25743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25746 }
25747 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25748 {
25749 PyThreadState* __tstate = wxPyBeginAllowThreads();
25750 result = (wxWindow *)(arg1)->GetChangedWindow();
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 {
25755 resultobj = wxPyMake_wxObject(result, (bool)0);
25756 }
25757 return resultobj;
25758 fail:
25759 return NULL;
25760 }
25761
25762
25763 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25764 PyObject *obj;
25765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25767 return SWIG_Py_Void();
25768 }
25769
25770 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25771 return SWIG_Python_InitShadowInstance(args);
25772 }
25773
25774 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj = 0;
25776 int arg1 = (int) 0 ;
25777 wxQueryNewPaletteEvent *result = 0 ;
25778 int val1 ;
25779 int ecode1 = 0 ;
25780 PyObject * obj0 = 0 ;
25781 char * kwnames[] = {
25782 (char *) "winid", NULL
25783 };
25784
25785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25786 if (obj0) {
25787 ecode1 = SWIG_AsVal_int(obj0, &val1);
25788 if (!SWIG_IsOK(ecode1)) {
25789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25790 }
25791 arg1 = static_cast< int >(val1);
25792 }
25793 {
25794 PyThreadState* __tstate = wxPyBeginAllowThreads();
25795 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25800 return resultobj;
25801 fail:
25802 return NULL;
25803 }
25804
25805
25806 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25807 PyObject *resultobj = 0;
25808 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25809 bool arg2 ;
25810 void *argp1 = 0 ;
25811 int res1 = 0 ;
25812 bool val2 ;
25813 int ecode2 = 0 ;
25814 PyObject * obj0 = 0 ;
25815 PyObject * obj1 = 0 ;
25816 char * kwnames[] = {
25817 (char *) "self",(char *) "realized", NULL
25818 };
25819
25820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25822 if (!SWIG_IsOK(res1)) {
25823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25824 }
25825 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25827 if (!SWIG_IsOK(ecode2)) {
25828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25829 }
25830 arg2 = static_cast< bool >(val2);
25831 {
25832 PyThreadState* __tstate = wxPyBeginAllowThreads();
25833 (arg1)->SetPaletteRealized(arg2);
25834 wxPyEndAllowThreads(__tstate);
25835 if (PyErr_Occurred()) SWIG_fail;
25836 }
25837 resultobj = SWIG_Py_Void();
25838 return resultobj;
25839 fail:
25840 return NULL;
25841 }
25842
25843
25844 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25845 PyObject *resultobj = 0;
25846 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25847 bool result;
25848 void *argp1 = 0 ;
25849 int res1 = 0 ;
25850 PyObject *swig_obj[1] ;
25851
25852 if (!args) SWIG_fail;
25853 swig_obj[0] = args;
25854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25855 if (!SWIG_IsOK(res1)) {
25856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25857 }
25858 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25859 {
25860 PyThreadState* __tstate = wxPyBeginAllowThreads();
25861 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25862 wxPyEndAllowThreads(__tstate);
25863 if (PyErr_Occurred()) SWIG_fail;
25864 }
25865 {
25866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25867 }
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25875 PyObject *obj;
25876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25877 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25878 return SWIG_Py_Void();
25879 }
25880
25881 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25882 return SWIG_Python_InitShadowInstance(args);
25883 }
25884
25885 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25886 PyObject *resultobj = 0;
25887 wxNavigationKeyEvent *result = 0 ;
25888
25889 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25897 return resultobj;
25898 fail:
25899 return NULL;
25900 }
25901
25902
25903 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25904 PyObject *resultobj = 0;
25905 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25906 bool result;
25907 void *argp1 = 0 ;
25908 int res1 = 0 ;
25909 PyObject *swig_obj[1] ;
25910
25911 if (!args) SWIG_fail;
25912 swig_obj[0] = args;
25913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25914 if (!SWIG_IsOK(res1)) {
25915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25916 }
25917 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25918 {
25919 PyThreadState* __tstate = wxPyBeginAllowThreads();
25920 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25921 wxPyEndAllowThreads(__tstate);
25922 if (PyErr_Occurred()) SWIG_fail;
25923 }
25924 {
25925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25926 }
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25934 PyObject *resultobj = 0;
25935 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25936 bool arg2 ;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 bool val2 ;
25940 int ecode2 = 0 ;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 char * kwnames[] = {
25944 (char *) "self",(char *) "forward", NULL
25945 };
25946
25947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25951 }
25952 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25953 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25954 if (!SWIG_IsOK(ecode2)) {
25955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25956 }
25957 arg2 = static_cast< bool >(val2);
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 (arg1)->SetDirection(arg2);
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_Py_Void();
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 PyObject *resultobj = 0;
25973 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25974 bool result;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 PyObject *swig_obj[1] ;
25978
25979 if (!args) SWIG_fail;
25980 swig_obj[0] = args;
25981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25984 }
25985 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 {
25993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25994 }
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26004 bool arg2 ;
26005 void *argp1 = 0 ;
26006 int res1 = 0 ;
26007 bool val2 ;
26008 int ecode2 = 0 ;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char * kwnames[] = {
26012 (char *) "self",(char *) "ischange", NULL
26013 };
26014
26015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26017 if (!SWIG_IsOK(res1)) {
26018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26019 }
26020 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26021 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26022 if (!SWIG_IsOK(ecode2)) {
26023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26024 }
26025 arg2 = static_cast< bool >(val2);
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 (arg1)->SetWindowChange(arg2);
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 resultobj = SWIG_Py_Void();
26033 return resultobj;
26034 fail:
26035 return NULL;
26036 }
26037
26038
26039 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26040 PyObject *resultobj = 0;
26041 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26042 bool result;
26043 void *argp1 = 0 ;
26044 int res1 = 0 ;
26045 PyObject *swig_obj[1] ;
26046
26047 if (!args) SWIG_fail;
26048 swig_obj[0] = args;
26049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26050 if (!SWIG_IsOK(res1)) {
26051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26052 }
26053 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26054 {
26055 PyThreadState* __tstate = wxPyBeginAllowThreads();
26056 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 {
26061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26062 }
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj = 0;
26071 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26072 bool arg2 ;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 bool val2 ;
26076 int ecode2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "bIs", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26087 }
26088 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26090 if (!SWIG_IsOK(ecode2)) {
26091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26092 }
26093 arg2 = static_cast< bool >(val2);
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 (arg1)->SetFromTab(arg2);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26108 PyObject *resultobj = 0;
26109 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26110 long arg2 ;
26111 void *argp1 = 0 ;
26112 int res1 = 0 ;
26113 long val2 ;
26114 int ecode2 = 0 ;
26115 PyObject * obj0 = 0 ;
26116 PyObject * obj1 = 0 ;
26117 char * kwnames[] = {
26118 (char *) "self",(char *) "flags", NULL
26119 };
26120
26121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26123 if (!SWIG_IsOK(res1)) {
26124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26125 }
26126 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26127 ecode2 = SWIG_AsVal_long(obj1, &val2);
26128 if (!SWIG_IsOK(ecode2)) {
26129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26130 }
26131 arg2 = static_cast< long >(val2);
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 (arg1)->SetFlags(arg2);
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_Py_Void();
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *resultobj = 0;
26147 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26148 wxWindow *result = 0 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 PyObject *swig_obj[1] ;
26152
26153 if (!args) SWIG_fail;
26154 swig_obj[0] = args;
26155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26158 }
26159 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 {
26167 resultobj = wxPyMake_wxObject(result, (bool)0);
26168 }
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26176 PyObject *resultobj = 0;
26177 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26178 wxWindow *arg2 = (wxWindow *) 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 void *argp2 = 0 ;
26182 int res2 = 0 ;
26183 PyObject * obj0 = 0 ;
26184 PyObject * obj1 = 0 ;
26185 char * kwnames[] = {
26186 (char *) "self",(char *) "win", NULL
26187 };
26188
26189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26191 if (!SWIG_IsOK(res1)) {
26192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26193 }
26194 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26196 if (!SWIG_IsOK(res2)) {
26197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26198 }
26199 arg2 = reinterpret_cast< wxWindow * >(argp2);
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 (arg1)->SetCurrentFocus(arg2);
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 resultobj = SWIG_Py_Void();
26207 return resultobj;
26208 fail:
26209 return NULL;
26210 }
26211
26212
26213 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26214 PyObject *obj;
26215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26216 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26217 return SWIG_Py_Void();
26218 }
26219
26220 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26221 return SWIG_Python_InitShadowInstance(args);
26222 }
26223
26224 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26225 PyObject *resultobj = 0;
26226 wxWindow *arg1 = (wxWindow *) NULL ;
26227 wxWindowCreateEvent *result = 0 ;
26228 void *argp1 = 0 ;
26229 int res1 = 0 ;
26230 PyObject * obj0 = 0 ;
26231 char * kwnames[] = {
26232 (char *) "win", NULL
26233 };
26234
26235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26236 if (obj0) {
26237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26238 if (!SWIG_IsOK(res1)) {
26239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26240 }
26241 arg1 = reinterpret_cast< wxWindow * >(argp1);
26242 }
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26246 wxPyEndAllowThreads(__tstate);
26247 if (PyErr_Occurred()) SWIG_fail;
26248 }
26249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26257 PyObject *resultobj = 0;
26258 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26259 wxWindow *result = 0 ;
26260 void *argp1 = 0 ;
26261 int res1 = 0 ;
26262 PyObject *swig_obj[1] ;
26263
26264 if (!args) SWIG_fail;
26265 swig_obj[0] = args;
26266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26267 if (!SWIG_IsOK(res1)) {
26268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26269 }
26270 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26271 {
26272 PyThreadState* __tstate = wxPyBeginAllowThreads();
26273 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26274 wxPyEndAllowThreads(__tstate);
26275 if (PyErr_Occurred()) SWIG_fail;
26276 }
26277 {
26278 resultobj = wxPyMake_wxObject(result, (bool)0);
26279 }
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26287 PyObject *obj;
26288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26289 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26290 return SWIG_Py_Void();
26291 }
26292
26293 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26294 return SWIG_Python_InitShadowInstance(args);
26295 }
26296
26297 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26298 PyObject *resultobj = 0;
26299 wxWindow *arg1 = (wxWindow *) NULL ;
26300 wxWindowDestroyEvent *result = 0 ;
26301 void *argp1 = 0 ;
26302 int res1 = 0 ;
26303 PyObject * obj0 = 0 ;
26304 char * kwnames[] = {
26305 (char *) "win", NULL
26306 };
26307
26308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26309 if (obj0) {
26310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26311 if (!SWIG_IsOK(res1)) {
26312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26313 }
26314 arg1 = reinterpret_cast< wxWindow * >(argp1);
26315 }
26316 {
26317 PyThreadState* __tstate = wxPyBeginAllowThreads();
26318 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26330 PyObject *resultobj = 0;
26331 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26332 wxWindow *result = 0 ;
26333 void *argp1 = 0 ;
26334 int res1 = 0 ;
26335 PyObject *swig_obj[1] ;
26336
26337 if (!args) SWIG_fail;
26338 swig_obj[0] = args;
26339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26340 if (!SWIG_IsOK(res1)) {
26341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26342 }
26343 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 {
26351 resultobj = wxPyMake_wxObject(result, (bool)0);
26352 }
26353 return resultobj;
26354 fail:
26355 return NULL;
26356 }
26357
26358
26359 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26360 PyObject *obj;
26361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26362 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26363 return SWIG_Py_Void();
26364 }
26365
26366 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26367 return SWIG_Python_InitShadowInstance(args);
26368 }
26369
26370 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26371 PyObject *resultobj = 0;
26372 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26373 int arg2 = (int) 0 ;
26374 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26375 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26376 wxContextMenuEvent *result = 0 ;
26377 int val1 ;
26378 int ecode1 = 0 ;
26379 int val2 ;
26380 int ecode2 = 0 ;
26381 wxPoint temp3 ;
26382 PyObject * obj0 = 0 ;
26383 PyObject * obj1 = 0 ;
26384 PyObject * obj2 = 0 ;
26385 char * kwnames[] = {
26386 (char *) "type",(char *) "winid",(char *) "pt", NULL
26387 };
26388
26389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26390 if (obj0) {
26391 ecode1 = SWIG_AsVal_int(obj0, &val1);
26392 if (!SWIG_IsOK(ecode1)) {
26393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26394 }
26395 arg1 = static_cast< wxEventType >(val1);
26396 }
26397 if (obj1) {
26398 ecode2 = SWIG_AsVal_int(obj1, &val2);
26399 if (!SWIG_IsOK(ecode2)) {
26400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26401 }
26402 arg2 = static_cast< int >(val2);
26403 }
26404 if (obj2) {
26405 {
26406 arg3 = &temp3;
26407 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26408 }
26409 }
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26424 PyObject *resultobj = 0;
26425 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26426 wxPoint *result = 0 ;
26427 void *argp1 = 0 ;
26428 int res1 = 0 ;
26429 PyObject *swig_obj[1] ;
26430
26431 if (!args) SWIG_fail;
26432 swig_obj[0] = args;
26433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26434 if (!SWIG_IsOK(res1)) {
26435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26436 }
26437 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 {
26441 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26442 result = (wxPoint *) &_result_ref;
26443 }
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26448 return resultobj;
26449 fail:
26450 return NULL;
26451 }
26452
26453
26454 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj = 0;
26456 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26457 wxPoint *arg2 = 0 ;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 wxPoint temp2 ;
26461 PyObject * obj0 = 0 ;
26462 PyObject * obj1 = 0 ;
26463 char * kwnames[] = {
26464 (char *) "self",(char *) "pos", NULL
26465 };
26466
26467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26469 if (!SWIG_IsOK(res1)) {
26470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26471 }
26472 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26473 {
26474 arg2 = &temp2;
26475 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26476 }
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 (arg1)->SetPosition((wxPoint const &)*arg2);
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 resultobj = SWIG_Py_Void();
26484 return resultobj;
26485 fail:
26486 return NULL;
26487 }
26488
26489
26490 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26491 PyObject *obj;
26492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26493 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26494 return SWIG_Py_Void();
26495 }
26496
26497 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26498 return SWIG_Python_InitShadowInstance(args);
26499 }
26500
26501 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26502 PyObject *resultobj = 0;
26503 wxIdleEvent *result = 0 ;
26504
26505 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (wxIdleEvent *)new wxIdleEvent();
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26520 PyObject *resultobj = 0;
26521 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26522 bool arg2 = (bool) true ;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 bool val2 ;
26526 int ecode2 = 0 ;
26527 PyObject * obj0 = 0 ;
26528 PyObject * obj1 = 0 ;
26529 char * kwnames[] = {
26530 (char *) "self",(char *) "needMore", NULL
26531 };
26532
26533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26535 if (!SWIG_IsOK(res1)) {
26536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26537 }
26538 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26539 if (obj1) {
26540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26541 if (!SWIG_IsOK(ecode2)) {
26542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26543 }
26544 arg2 = static_cast< bool >(val2);
26545 }
26546 {
26547 PyThreadState* __tstate = wxPyBeginAllowThreads();
26548 (arg1)->RequestMore(arg2);
26549 wxPyEndAllowThreads(__tstate);
26550 if (PyErr_Occurred()) SWIG_fail;
26551 }
26552 resultobj = SWIG_Py_Void();
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26560 PyObject *resultobj = 0;
26561 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26562 bool result;
26563 void *argp1 = 0 ;
26564 int res1 = 0 ;
26565 PyObject *swig_obj[1] ;
26566
26567 if (!args) SWIG_fail;
26568 swig_obj[0] = args;
26569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26570 if (!SWIG_IsOK(res1)) {
26571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26572 }
26573 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 {
26581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26582 }
26583 return resultobj;
26584 fail:
26585 return NULL;
26586 }
26587
26588
26589 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26590 PyObject *resultobj = 0;
26591 wxIdleMode arg1 ;
26592 int val1 ;
26593 int ecode1 = 0 ;
26594 PyObject * obj0 = 0 ;
26595 char * kwnames[] = {
26596 (char *) "mode", NULL
26597 };
26598
26599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26600 ecode1 = SWIG_AsVal_int(obj0, &val1);
26601 if (!SWIG_IsOK(ecode1)) {
26602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26603 }
26604 arg1 = static_cast< wxIdleMode >(val1);
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 wxIdleEvent::SetMode(arg1);
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 resultobj = SWIG_Py_Void();
26612 return resultobj;
26613 fail:
26614 return NULL;
26615 }
26616
26617
26618 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26619 PyObject *resultobj = 0;
26620 wxIdleMode result;
26621
26622 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 result = (wxIdleMode)wxIdleEvent::GetMode();
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_From_int(static_cast< int >(result));
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj = 0;
26638 wxWindow *arg1 = (wxWindow *) 0 ;
26639 bool result;
26640 void *argp1 = 0 ;
26641 int res1 = 0 ;
26642 PyObject * obj0 = 0 ;
26643 char * kwnames[] = {
26644 (char *) "win", NULL
26645 };
26646
26647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26649 if (!SWIG_IsOK(res1)) {
26650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26651 }
26652 arg1 = reinterpret_cast< wxWindow * >(argp1);
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 result = (bool)wxIdleEvent::CanSend(arg1);
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 {
26660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26661 }
26662 return resultobj;
26663 fail:
26664 return NULL;
26665 }
26666
26667
26668 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26669 PyObject *obj;
26670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26671 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26672 return SWIG_Py_Void();
26673 }
26674
26675 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26676 return SWIG_Python_InitShadowInstance(args);
26677 }
26678
26679 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = 0;
26681 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26682 int arg2 = (int) 0 ;
26683 wxClipboardTextEvent *result = 0 ;
26684 int val1 ;
26685 int ecode1 = 0 ;
26686 int val2 ;
26687 int ecode2 = 0 ;
26688 PyObject * obj0 = 0 ;
26689 PyObject * obj1 = 0 ;
26690 char * kwnames[] = {
26691 (char *) "type",(char *) "winid", NULL
26692 };
26693
26694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26695 if (obj0) {
26696 ecode1 = SWIG_AsVal_int(obj0, &val1);
26697 if (!SWIG_IsOK(ecode1)) {
26698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26699 }
26700 arg1 = static_cast< wxEventType >(val1);
26701 }
26702 if (obj1) {
26703 ecode2 = SWIG_AsVal_int(obj1, &val2);
26704 if (!SWIG_IsOK(ecode2)) {
26705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26706 }
26707 arg2 = static_cast< int >(val2);
26708 }
26709 {
26710 PyThreadState* __tstate = wxPyBeginAllowThreads();
26711 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26723 PyObject *obj;
26724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26725 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26726 return SWIG_Py_Void();
26727 }
26728
26729 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26730 return SWIG_Python_InitShadowInstance(args);
26731 }
26732
26733 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26734 PyObject *resultobj = 0;
26735 int arg1 = (int) 0 ;
26736 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26737 wxPyEvent *result = 0 ;
26738 int val1 ;
26739 int ecode1 = 0 ;
26740 int val2 ;
26741 int ecode2 = 0 ;
26742 PyObject * obj0 = 0 ;
26743 PyObject * obj1 = 0 ;
26744 char * kwnames[] = {
26745 (char *) "winid",(char *) "eventType", NULL
26746 };
26747
26748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26749 if (obj0) {
26750 ecode1 = SWIG_AsVal_int(obj0, &val1);
26751 if (!SWIG_IsOK(ecode1)) {
26752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26753 }
26754 arg1 = static_cast< int >(val1);
26755 }
26756 if (obj1) {
26757 ecode2 = SWIG_AsVal_int(obj1, &val2);
26758 if (!SWIG_IsOK(ecode2)) {
26759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26760 }
26761 arg2 = static_cast< wxEventType >(val2);
26762 }
26763 {
26764 PyThreadState* __tstate = wxPyBeginAllowThreads();
26765 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26766 wxPyEndAllowThreads(__tstate);
26767 if (PyErr_Occurred()) SWIG_fail;
26768 }
26769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26770 return resultobj;
26771 fail:
26772 return NULL;
26773 }
26774
26775
26776 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26777 PyObject *resultobj = 0;
26778 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26779 void *argp1 = 0 ;
26780 int res1 = 0 ;
26781 PyObject *swig_obj[1] ;
26782
26783 if (!args) SWIG_fail;
26784 swig_obj[0] = args;
26785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26786 if (!SWIG_IsOK(res1)) {
26787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26788 }
26789 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 delete arg1;
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 resultobj = SWIG_Py_Void();
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj = 0;
26806 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26807 PyObject *arg2 = (PyObject *) 0 ;
26808 void *argp1 = 0 ;
26809 int res1 = 0 ;
26810 PyObject * obj0 = 0 ;
26811 PyObject * obj1 = 0 ;
26812 char * kwnames[] = {
26813 (char *) "self",(char *) "self", NULL
26814 };
26815
26816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26818 if (!SWIG_IsOK(res1)) {
26819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26820 }
26821 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26822 arg2 = obj1;
26823 {
26824 PyThreadState* __tstate = wxPyBeginAllowThreads();
26825 (arg1)->SetSelf(arg2);
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 resultobj = SWIG_Py_Void();
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26837 PyObject *resultobj = 0;
26838 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26839 PyObject *result = 0 ;
26840 void *argp1 = 0 ;
26841 int res1 = 0 ;
26842 PyObject *swig_obj[1] ;
26843
26844 if (!args) SWIG_fail;
26845 swig_obj[0] = args;
26846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26847 if (!SWIG_IsOK(res1)) {
26848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26849 }
26850 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26851 {
26852 PyThreadState* __tstate = wxPyBeginAllowThreads();
26853 result = (PyObject *)(arg1)->GetSelf();
26854 wxPyEndAllowThreads(__tstate);
26855 if (PyErr_Occurred()) SWIG_fail;
26856 }
26857 resultobj = result;
26858 return resultobj;
26859 fail:
26860 return NULL;
26861 }
26862
26863
26864 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26865 PyObject *obj;
26866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26867 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26868 return SWIG_Py_Void();
26869 }
26870
26871 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 return SWIG_Python_InitShadowInstance(args);
26873 }
26874
26875 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26876 PyObject *resultobj = 0;
26877 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26878 int arg2 = (int) 0 ;
26879 wxPyCommandEvent *result = 0 ;
26880 int val1 ;
26881 int ecode1 = 0 ;
26882 int val2 ;
26883 int ecode2 = 0 ;
26884 PyObject * obj0 = 0 ;
26885 PyObject * obj1 = 0 ;
26886 char * kwnames[] = {
26887 (char *) "eventType",(char *) "id", NULL
26888 };
26889
26890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26891 if (obj0) {
26892 ecode1 = SWIG_AsVal_int(obj0, &val1);
26893 if (!SWIG_IsOK(ecode1)) {
26894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26895 }
26896 arg1 = static_cast< wxEventType >(val1);
26897 }
26898 if (obj1) {
26899 ecode2 = SWIG_AsVal_int(obj1, &val2);
26900 if (!SWIG_IsOK(ecode2)) {
26901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26902 }
26903 arg2 = static_cast< int >(val2);
26904 }
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26919 PyObject *resultobj = 0;
26920 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26921 void *argp1 = 0 ;
26922 int res1 = 0 ;
26923 PyObject *swig_obj[1] ;
26924
26925 if (!args) SWIG_fail;
26926 swig_obj[0] = args;
26927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26928 if (!SWIG_IsOK(res1)) {
26929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26930 }
26931 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 delete arg1;
26935
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 resultobj = SWIG_Py_Void();
26940 return resultobj;
26941 fail:
26942 return NULL;
26943 }
26944
26945
26946 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26947 PyObject *resultobj = 0;
26948 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26949 PyObject *arg2 = (PyObject *) 0 ;
26950 void *argp1 = 0 ;
26951 int res1 = 0 ;
26952 PyObject * obj0 = 0 ;
26953 PyObject * obj1 = 0 ;
26954 char * kwnames[] = {
26955 (char *) "self",(char *) "self", NULL
26956 };
26957
26958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26960 if (!SWIG_IsOK(res1)) {
26961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26962 }
26963 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26964 arg2 = obj1;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 (arg1)->SetSelf(arg2);
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 resultobj = SWIG_Py_Void();
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26979 PyObject *resultobj = 0;
26980 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26981 PyObject *result = 0 ;
26982 void *argp1 = 0 ;
26983 int res1 = 0 ;
26984 PyObject *swig_obj[1] ;
26985
26986 if (!args) SWIG_fail;
26987 swig_obj[0] = args;
26988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26989 if (!SWIG_IsOK(res1)) {
26990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26991 }
26992 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = (PyObject *)(arg1)->GetSelf();
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 resultobj = result;
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27007 PyObject *obj;
27008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27009 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27010 return SWIG_Py_Void();
27011 }
27012
27013 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27014 return SWIG_Python_InitShadowInstance(args);
27015 }
27016
27017 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj = 0;
27019 wxWindow *arg1 = (wxWindow *) 0 ;
27020 wxDateTime *arg2 = 0 ;
27021 wxEventType arg3 ;
27022 wxDateEvent *result = 0 ;
27023 void *argp1 = 0 ;
27024 int res1 = 0 ;
27025 void *argp2 = 0 ;
27026 int res2 = 0 ;
27027 int val3 ;
27028 int ecode3 = 0 ;
27029 PyObject * obj0 = 0 ;
27030 PyObject * obj1 = 0 ;
27031 PyObject * obj2 = 0 ;
27032 char * kwnames[] = {
27033 (char *) "win",(char *) "dt",(char *) "type", NULL
27034 };
27035
27036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27038 if (!SWIG_IsOK(res1)) {
27039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27040 }
27041 arg1 = reinterpret_cast< wxWindow * >(argp1);
27042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27043 if (!SWIG_IsOK(res2)) {
27044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27045 }
27046 if (!argp2) {
27047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27048 }
27049 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27050 ecode3 = SWIG_AsVal_int(obj2, &val3);
27051 if (!SWIG_IsOK(ecode3)) {
27052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27053 }
27054 arg3 = static_cast< wxEventType >(val3);
27055 {
27056 PyThreadState* __tstate = wxPyBeginAllowThreads();
27057 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27069 PyObject *resultobj = 0;
27070 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27071 wxDateTime *result = 0 ;
27072 void *argp1 = 0 ;
27073 int res1 = 0 ;
27074 PyObject *swig_obj[1] ;
27075
27076 if (!args) SWIG_fail;
27077 swig_obj[0] = args;
27078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27079 if (!SWIG_IsOK(res1)) {
27080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27081 }
27082 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 {
27086 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27087 result = (wxDateTime *) &_result_ref;
27088 }
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj = 0;
27101 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27102 wxDateTime *arg2 = 0 ;
27103 void *argp1 = 0 ;
27104 int res1 = 0 ;
27105 void *argp2 = 0 ;
27106 int res2 = 0 ;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 char * kwnames[] = {
27110 (char *) "self",(char *) "date", NULL
27111 };
27112
27113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27115 if (!SWIG_IsOK(res1)) {
27116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27117 }
27118 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27120 if (!SWIG_IsOK(res2)) {
27121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27122 }
27123 if (!argp2) {
27124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27125 }
27126 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27127 {
27128 PyThreadState* __tstate = wxPyBeginAllowThreads();
27129 (arg1)->SetDate((wxDateTime const &)*arg2);
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 resultobj = SWIG_Py_Void();
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27141 PyObject *obj;
27142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27143 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27144 return SWIG_Py_Void();
27145 }
27146
27147 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27148 return SWIG_Python_InitShadowInstance(args);
27149 }
27150
27151 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27152 PyObject *resultobj = 0;
27153 wxPyApp *result = 0 ;
27154
27155 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 result = (wxPyApp *)new_wxPyApp();
27159 wxPyEndAllowThreads(__tstate);
27160 if (PyErr_Occurred()) SWIG_fail;
27161 }
27162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27163 return resultobj;
27164 fail:
27165 return NULL;
27166 }
27167
27168
27169 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27170 PyObject *resultobj = 0;
27171 wxPyApp *arg1 = (wxPyApp *) 0 ;
27172 void *argp1 = 0 ;
27173 int res1 = 0 ;
27174 PyObject *swig_obj[1] ;
27175
27176 if (!args) SWIG_fail;
27177 swig_obj[0] = args;
27178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27179 if (!SWIG_IsOK(res1)) {
27180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27181 }
27182 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 delete arg1;
27186
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_Py_Void();
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27198 PyObject *resultobj = 0;
27199 wxPyApp *arg1 = (wxPyApp *) 0 ;
27200 PyObject *arg2 = (PyObject *) 0 ;
27201 PyObject *arg3 = (PyObject *) 0 ;
27202 bool arg4 ;
27203 void *argp1 = 0 ;
27204 int res1 = 0 ;
27205 bool val4 ;
27206 int ecode4 = 0 ;
27207 PyObject * obj0 = 0 ;
27208 PyObject * obj1 = 0 ;
27209 PyObject * obj2 = 0 ;
27210 PyObject * obj3 = 0 ;
27211 char * kwnames[] = {
27212 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27213 };
27214
27215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27217 if (!SWIG_IsOK(res1)) {
27218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27219 }
27220 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27221 arg2 = obj1;
27222 arg3 = obj2;
27223 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27224 if (!SWIG_IsOK(ecode4)) {
27225 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27226 }
27227 arg4 = static_cast< bool >(val4);
27228 {
27229 PyThreadState* __tstate = wxPyBeginAllowThreads();
27230 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27231 wxPyEndAllowThreads(__tstate);
27232 if (PyErr_Occurred()) SWIG_fail;
27233 }
27234 resultobj = SWIG_Py_Void();
27235 return resultobj;
27236 fail:
27237 return NULL;
27238 }
27239
27240
27241 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27242 PyObject *resultobj = 0;
27243 wxPyApp *arg1 = (wxPyApp *) 0 ;
27244 wxString result;
27245 void *argp1 = 0 ;
27246 int res1 = 0 ;
27247 PyObject *swig_obj[1] ;
27248
27249 if (!args) SWIG_fail;
27250 swig_obj[0] = args;
27251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27252 if (!SWIG_IsOK(res1)) {
27253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27254 }
27255 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27256 {
27257 PyThreadState* __tstate = wxPyBeginAllowThreads();
27258 result = ((wxPyApp const *)arg1)->GetAppName();
27259 wxPyEndAllowThreads(__tstate);
27260 if (PyErr_Occurred()) SWIG_fail;
27261 }
27262 {
27263 #if wxUSE_UNICODE
27264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27265 #else
27266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27267 #endif
27268 }
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27276 PyObject *resultobj = 0;
27277 wxPyApp *arg1 = (wxPyApp *) 0 ;
27278 wxString *arg2 = 0 ;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 bool temp2 = false ;
27282 PyObject * obj0 = 0 ;
27283 PyObject * obj1 = 0 ;
27284 char * kwnames[] = {
27285 (char *) "self",(char *) "name", NULL
27286 };
27287
27288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27290 if (!SWIG_IsOK(res1)) {
27291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27292 }
27293 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27294 {
27295 arg2 = wxString_in_helper(obj1);
27296 if (arg2 == NULL) SWIG_fail;
27297 temp2 = true;
27298 }
27299 {
27300 PyThreadState* __tstate = wxPyBeginAllowThreads();
27301 (arg1)->SetAppName((wxString const &)*arg2);
27302 wxPyEndAllowThreads(__tstate);
27303 if (PyErr_Occurred()) SWIG_fail;
27304 }
27305 resultobj = SWIG_Py_Void();
27306 {
27307 if (temp2)
27308 delete arg2;
27309 }
27310 return resultobj;
27311 fail:
27312 {
27313 if (temp2)
27314 delete arg2;
27315 }
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27321 PyObject *resultobj = 0;
27322 wxPyApp *arg1 = (wxPyApp *) 0 ;
27323 wxString result;
27324 void *argp1 = 0 ;
27325 int res1 = 0 ;
27326 PyObject *swig_obj[1] ;
27327
27328 if (!args) SWIG_fail;
27329 swig_obj[0] = args;
27330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27331 if (!SWIG_IsOK(res1)) {
27332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27333 }
27334 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 result = ((wxPyApp const *)arg1)->GetClassName();
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 {
27342 #if wxUSE_UNICODE
27343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27344 #else
27345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27346 #endif
27347 }
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27355 PyObject *resultobj = 0;
27356 wxPyApp *arg1 = (wxPyApp *) 0 ;
27357 wxString *arg2 = 0 ;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 bool temp2 = false ;
27361 PyObject * obj0 = 0 ;
27362 PyObject * obj1 = 0 ;
27363 char * kwnames[] = {
27364 (char *) "self",(char *) "name", NULL
27365 };
27366
27367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27369 if (!SWIG_IsOK(res1)) {
27370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27371 }
27372 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27373 {
27374 arg2 = wxString_in_helper(obj1);
27375 if (arg2 == NULL) SWIG_fail;
27376 temp2 = true;
27377 }
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 (arg1)->SetClassName((wxString const &)*arg2);
27381 wxPyEndAllowThreads(__tstate);
27382 if (PyErr_Occurred()) SWIG_fail;
27383 }
27384 resultobj = SWIG_Py_Void();
27385 {
27386 if (temp2)
27387 delete arg2;
27388 }
27389 return resultobj;
27390 fail:
27391 {
27392 if (temp2)
27393 delete arg2;
27394 }
27395 return NULL;
27396 }
27397
27398
27399 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27400 PyObject *resultobj = 0;
27401 wxPyApp *arg1 = (wxPyApp *) 0 ;
27402 wxString *result = 0 ;
27403 void *argp1 = 0 ;
27404 int res1 = 0 ;
27405 PyObject *swig_obj[1] ;
27406
27407 if (!args) SWIG_fail;
27408 swig_obj[0] = args;
27409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27410 if (!SWIG_IsOK(res1)) {
27411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27412 }
27413 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 {
27417 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27418 result = (wxString *) &_result_ref;
27419 }
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 {
27424 #if wxUSE_UNICODE
27425 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27426 #else
27427 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27428 #endif
27429 }
27430 return resultobj;
27431 fail:
27432 return NULL;
27433 }
27434
27435
27436 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27437 PyObject *resultobj = 0;
27438 wxPyApp *arg1 = (wxPyApp *) 0 ;
27439 wxString *arg2 = 0 ;
27440 void *argp1 = 0 ;
27441 int res1 = 0 ;
27442 bool temp2 = false ;
27443 PyObject * obj0 = 0 ;
27444 PyObject * obj1 = 0 ;
27445 char * kwnames[] = {
27446 (char *) "self",(char *) "name", NULL
27447 };
27448
27449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27453 }
27454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27455 {
27456 arg2 = wxString_in_helper(obj1);
27457 if (arg2 == NULL) SWIG_fail;
27458 temp2 = true;
27459 }
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 (arg1)->SetVendorName((wxString const &)*arg2);
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 resultobj = SWIG_Py_Void();
27467 {
27468 if (temp2)
27469 delete arg2;
27470 }
27471 return resultobj;
27472 fail:
27473 {
27474 if (temp2)
27475 delete arg2;
27476 }
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27482 PyObject *resultobj = 0;
27483 wxPyApp *arg1 = (wxPyApp *) 0 ;
27484 wxAppTraits *result = 0 ;
27485 void *argp1 = 0 ;
27486 int res1 = 0 ;
27487 PyObject *swig_obj[1] ;
27488
27489 if (!args) SWIG_fail;
27490 swig_obj[0] = args;
27491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27494 }
27495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 result = (wxAppTraits *)(arg1)->GetTraits();
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27510 PyObject *resultobj = 0;
27511 wxPyApp *arg1 = (wxPyApp *) 0 ;
27512 void *argp1 = 0 ;
27513 int res1 = 0 ;
27514 PyObject *swig_obj[1] ;
27515
27516 if (!args) SWIG_fail;
27517 swig_obj[0] = args;
27518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27519 if (!SWIG_IsOK(res1)) {
27520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27521 }
27522 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 (arg1)->ProcessPendingEvents();
27526 wxPyEndAllowThreads(__tstate);
27527 if (PyErr_Occurred()) SWIG_fail;
27528 }
27529 resultobj = SWIG_Py_Void();
27530 return resultobj;
27531 fail:
27532 return NULL;
27533 }
27534
27535
27536 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27537 PyObject *resultobj = 0;
27538 wxPyApp *arg1 = (wxPyApp *) 0 ;
27539 bool arg2 = (bool) false ;
27540 bool result;
27541 void *argp1 = 0 ;
27542 int res1 = 0 ;
27543 bool val2 ;
27544 int ecode2 = 0 ;
27545 PyObject * obj0 = 0 ;
27546 PyObject * obj1 = 0 ;
27547 char * kwnames[] = {
27548 (char *) "self",(char *) "onlyIfNeeded", NULL
27549 };
27550
27551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27553 if (!SWIG_IsOK(res1)) {
27554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27555 }
27556 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27557 if (obj1) {
27558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27559 if (!SWIG_IsOK(ecode2)) {
27560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27561 }
27562 arg2 = static_cast< bool >(val2);
27563 }
27564 {
27565 PyThreadState* __tstate = wxPyBeginAllowThreads();
27566 result = (bool)(arg1)->Yield(arg2);
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 {
27571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27572 }
27573 return resultobj;
27574 fail:
27575 return NULL;
27576 }
27577
27578
27579 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27580 PyObject *resultobj = 0;
27581 wxPyApp *arg1 = (wxPyApp *) 0 ;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 PyObject *swig_obj[1] ;
27585
27586 if (!args) SWIG_fail;
27587 swig_obj[0] = args;
27588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27589 if (!SWIG_IsOK(res1)) {
27590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27591 }
27592 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27593 {
27594 PyThreadState* __tstate = wxPyBeginAllowThreads();
27595 (arg1)->WakeUpIdle();
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 resultobj = SWIG_Py_Void();
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27607 PyObject *resultobj = 0;
27608 bool result;
27609
27610 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27611 {
27612 PyThreadState* __tstate = wxPyBeginAllowThreads();
27613 result = (bool)wxPyApp::IsMainLoopRunning();
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 {
27618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27619 }
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27627 PyObject *resultobj = 0;
27628 wxPyApp *arg1 = (wxPyApp *) 0 ;
27629 int result;
27630 void *argp1 = 0 ;
27631 int res1 = 0 ;
27632 PyObject *swig_obj[1] ;
27633
27634 if (!args) SWIG_fail;
27635 swig_obj[0] = args;
27636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27637 if (!SWIG_IsOK(res1)) {
27638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27639 }
27640 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27641 {
27642 PyThreadState* __tstate = wxPyBeginAllowThreads();
27643 result = (int)(arg1)->MainLoop();
27644 wxPyEndAllowThreads(__tstate);
27645 if (PyErr_Occurred()) SWIG_fail;
27646 }
27647 resultobj = SWIG_From_int(static_cast< int >(result));
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxPyApp *arg1 = (wxPyApp *) 0 ;
27657 void *argp1 = 0 ;
27658 int res1 = 0 ;
27659 PyObject *swig_obj[1] ;
27660
27661 if (!args) SWIG_fail;
27662 swig_obj[0] = args;
27663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27664 if (!SWIG_IsOK(res1)) {
27665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27666 }
27667 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 (arg1)->Exit();
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_Py_Void();
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27682 PyObject *resultobj = 0;
27683 wxPyApp *arg1 = (wxPyApp *) 0 ;
27684 void *argp1 = 0 ;
27685 int res1 = 0 ;
27686 PyObject *swig_obj[1] ;
27687
27688 if (!args) SWIG_fail;
27689 swig_obj[0] = args;
27690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27691 if (!SWIG_IsOK(res1)) {
27692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27693 }
27694 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 (arg1)->ExitMainLoop();
27698 wxPyEndAllowThreads(__tstate);
27699 if (PyErr_Occurred()) SWIG_fail;
27700 }
27701 resultobj = SWIG_Py_Void();
27702 return resultobj;
27703 fail:
27704 return NULL;
27705 }
27706
27707
27708 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27709 PyObject *resultobj = 0;
27710 wxPyApp *arg1 = (wxPyApp *) 0 ;
27711 bool result;
27712 void *argp1 = 0 ;
27713 int res1 = 0 ;
27714 PyObject *swig_obj[1] ;
27715
27716 if (!args) SWIG_fail;
27717 swig_obj[0] = args;
27718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27721 }
27722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (bool)(arg1)->Pending();
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *resultobj = 0;
27740 wxPyApp *arg1 = (wxPyApp *) 0 ;
27741 bool result;
27742 void *argp1 = 0 ;
27743 int res1 = 0 ;
27744 PyObject *swig_obj[1] ;
27745
27746 if (!args) SWIG_fail;
27747 swig_obj[0] = args;
27748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27751 }
27752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (bool)(arg1)->Dispatch();
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 {
27760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27761 }
27762 return resultobj;
27763 fail:
27764 return NULL;
27765 }
27766
27767
27768 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27769 PyObject *resultobj = 0;
27770 wxPyApp *arg1 = (wxPyApp *) 0 ;
27771 bool result;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 PyObject *swig_obj[1] ;
27775
27776 if (!args) SWIG_fail;
27777 swig_obj[0] = args;
27778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27779 if (!SWIG_IsOK(res1)) {
27780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27781 }
27782 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27783 {
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = (bool)(arg1)->ProcessIdle();
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 {
27790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27791 }
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27799 PyObject *resultobj = 0;
27800 wxPyApp *arg1 = (wxPyApp *) 0 ;
27801 wxWindow *arg2 = (wxWindow *) 0 ;
27802 wxIdleEvent *arg3 = 0 ;
27803 bool result;
27804 void *argp1 = 0 ;
27805 int res1 = 0 ;
27806 void *argp2 = 0 ;
27807 int res2 = 0 ;
27808 void *argp3 = 0 ;
27809 int res3 = 0 ;
27810 PyObject * obj0 = 0 ;
27811 PyObject * obj1 = 0 ;
27812 PyObject * obj2 = 0 ;
27813 char * kwnames[] = {
27814 (char *) "self",(char *) "win",(char *) "event", NULL
27815 };
27816
27817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27819 if (!SWIG_IsOK(res1)) {
27820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27821 }
27822 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27823 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27824 if (!SWIG_IsOK(res2)) {
27825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27826 }
27827 arg2 = reinterpret_cast< wxWindow * >(argp2);
27828 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27829 if (!SWIG_IsOK(res3)) {
27830 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27831 }
27832 if (!argp3) {
27833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27834 }
27835 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 {
27843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27844 }
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27852 PyObject *resultobj = 0;
27853 wxPyApp *arg1 = (wxPyApp *) 0 ;
27854 bool result;
27855 void *argp1 = 0 ;
27856 int res1 = 0 ;
27857 PyObject *swig_obj[1] ;
27858
27859 if (!args) SWIG_fail;
27860 swig_obj[0] = args;
27861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27862 if (!SWIG_IsOK(res1)) {
27863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27864 }
27865 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = (bool)((wxPyApp const *)arg1)->IsActive();
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27874 }
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27882 PyObject *resultobj = 0;
27883 wxPyApp *arg1 = (wxPyApp *) 0 ;
27884 wxWindow *arg2 = (wxWindow *) 0 ;
27885 void *argp1 = 0 ;
27886 int res1 = 0 ;
27887 void *argp2 = 0 ;
27888 int res2 = 0 ;
27889 PyObject * obj0 = 0 ;
27890 PyObject * obj1 = 0 ;
27891 char * kwnames[] = {
27892 (char *) "self",(char *) "win", NULL
27893 };
27894
27895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27897 if (!SWIG_IsOK(res1)) {
27898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27899 }
27900 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27901 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27902 if (!SWIG_IsOK(res2)) {
27903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27904 }
27905 arg2 = reinterpret_cast< wxWindow * >(argp2);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 (arg1)->SetTopWindow(arg2);
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_Py_Void();
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 wxPyApp *arg1 = (wxPyApp *) 0 ;
27922 wxWindow *result = 0 ;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 PyObject *swig_obj[1] ;
27926
27927 if (!args) SWIG_fail;
27928 swig_obj[0] = args;
27929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27930 if (!SWIG_IsOK(res1)) {
27931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27932 }
27933 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 resultobj = wxPyMake_wxObject(result, (bool)0);
27942 }
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj = 0;
27951 wxPyApp *arg1 = (wxPyApp *) 0 ;
27952 bool arg2 ;
27953 void *argp1 = 0 ;
27954 int res1 = 0 ;
27955 bool val2 ;
27956 int ecode2 = 0 ;
27957 PyObject * obj0 = 0 ;
27958 PyObject * obj1 = 0 ;
27959 char * kwnames[] = {
27960 (char *) "self",(char *) "flag", NULL
27961 };
27962
27963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27965 if (!SWIG_IsOK(res1)) {
27966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27967 }
27968 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27970 if (!SWIG_IsOK(ecode2)) {
27971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27972 }
27973 arg2 = static_cast< bool >(val2);
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 (arg1)->SetExitOnFrameDelete(arg2);
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 resultobj = SWIG_Py_Void();
27981 return resultobj;
27982 fail:
27983 return NULL;
27984 }
27985
27986
27987 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27988 PyObject *resultobj = 0;
27989 wxPyApp *arg1 = (wxPyApp *) 0 ;
27990 bool result;
27991 void *argp1 = 0 ;
27992 int res1 = 0 ;
27993 PyObject *swig_obj[1] ;
27994
27995 if (!args) SWIG_fail;
27996 swig_obj[0] = args;
27997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28000 }
28001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28002 {
28003 PyThreadState* __tstate = wxPyBeginAllowThreads();
28004 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 {
28009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj = 0;
28019 wxPyApp *arg1 = (wxPyApp *) 0 ;
28020 bool arg2 ;
28021 void *argp1 = 0 ;
28022 int res1 = 0 ;
28023 bool val2 ;
28024 int ecode2 = 0 ;
28025 PyObject * obj0 = 0 ;
28026 PyObject * obj1 = 0 ;
28027 char * kwnames[] = {
28028 (char *) "self",(char *) "flag", NULL
28029 };
28030
28031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28033 if (!SWIG_IsOK(res1)) {
28034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28035 }
28036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28037 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28038 if (!SWIG_IsOK(ecode2)) {
28039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28040 }
28041 arg2 = static_cast< bool >(val2);
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 (arg1)->SetUseBestVisual(arg2);
28045 wxPyEndAllowThreads(__tstate);
28046 if (PyErr_Occurred()) SWIG_fail;
28047 }
28048 resultobj = SWIG_Py_Void();
28049 return resultobj;
28050 fail:
28051 return NULL;
28052 }
28053
28054
28055 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28056 PyObject *resultobj = 0;
28057 wxPyApp *arg1 = (wxPyApp *) 0 ;
28058 bool result;
28059 void *argp1 = 0 ;
28060 int res1 = 0 ;
28061 PyObject *swig_obj[1] ;
28062
28063 if (!args) SWIG_fail;
28064 swig_obj[0] = args;
28065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28066 if (!SWIG_IsOK(res1)) {
28067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28068 }
28069 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 {
28077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28078 }
28079 return resultobj;
28080 fail:
28081 return NULL;
28082 }
28083
28084
28085 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28086 PyObject *resultobj = 0;
28087 wxPyApp *arg1 = (wxPyApp *) 0 ;
28088 int arg2 ;
28089 void *argp1 = 0 ;
28090 int res1 = 0 ;
28091 int val2 ;
28092 int ecode2 = 0 ;
28093 PyObject * obj0 = 0 ;
28094 PyObject * obj1 = 0 ;
28095 char * kwnames[] = {
28096 (char *) "self",(char *) "mode", NULL
28097 };
28098
28099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28101 if (!SWIG_IsOK(res1)) {
28102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28103 }
28104 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28105 ecode2 = SWIG_AsVal_int(obj1, &val2);
28106 if (!SWIG_IsOK(ecode2)) {
28107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28108 }
28109 arg2 = static_cast< int >(val2);
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 (arg1)->SetPrintMode(arg2);
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_Py_Void();
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28124 PyObject *resultobj = 0;
28125 wxPyApp *arg1 = (wxPyApp *) 0 ;
28126 int result;
28127 void *argp1 = 0 ;
28128 int res1 = 0 ;
28129 PyObject *swig_obj[1] ;
28130
28131 if (!args) SWIG_fail;
28132 swig_obj[0] = args;
28133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28134 if (!SWIG_IsOK(res1)) {
28135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28136 }
28137 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 resultobj = SWIG_From_int(static_cast< int >(result));
28145 return resultobj;
28146 fail:
28147 return NULL;
28148 }
28149
28150
28151 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28152 PyObject *resultobj = 0;
28153 wxPyApp *arg1 = (wxPyApp *) 0 ;
28154 int arg2 ;
28155 void *argp1 = 0 ;
28156 int res1 = 0 ;
28157 int val2 ;
28158 int ecode2 = 0 ;
28159 PyObject * obj0 = 0 ;
28160 PyObject * obj1 = 0 ;
28161 char * kwnames[] = {
28162 (char *) "self",(char *) "mode", NULL
28163 };
28164
28165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28167 if (!SWIG_IsOK(res1)) {
28168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28169 }
28170 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28171 ecode2 = SWIG_AsVal_int(obj1, &val2);
28172 if (!SWIG_IsOK(ecode2)) {
28173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28174 }
28175 arg2 = static_cast< int >(val2);
28176 {
28177 PyThreadState* __tstate = wxPyBeginAllowThreads();
28178 (arg1)->SetAssertMode(arg2);
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 resultobj = SWIG_Py_Void();
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28190 PyObject *resultobj = 0;
28191 wxPyApp *arg1 = (wxPyApp *) 0 ;
28192 int result;
28193 void *argp1 = 0 ;
28194 int res1 = 0 ;
28195 PyObject *swig_obj[1] ;
28196
28197 if (!args) SWIG_fail;
28198 swig_obj[0] = args;
28199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28200 if (!SWIG_IsOK(res1)) {
28201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28202 }
28203 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28204 {
28205 PyThreadState* __tstate = wxPyBeginAllowThreads();
28206 result = (int)(arg1)->GetAssertMode();
28207 wxPyEndAllowThreads(__tstate);
28208 if (PyErr_Occurred()) SWIG_fail;
28209 }
28210 resultobj = SWIG_From_int(static_cast< int >(result));
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28218 PyObject *resultobj = 0;
28219 bool result;
28220
28221 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 {
28229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28230 }
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239 long result;
28240
28241 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (long)wxPyApp::GetMacAboutMenuItemId();
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 resultobj = SWIG_From_long(static_cast< long >(result));
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28256 PyObject *resultobj = 0;
28257 long result;
28258
28259 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28260 {
28261 PyThreadState* __tstate = wxPyBeginAllowThreads();
28262 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 resultobj = SWIG_From_long(static_cast< long >(result));
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28274 PyObject *resultobj = 0;
28275 long result;
28276
28277 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (long)wxPyApp::GetMacExitMenuItemId();
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 resultobj = SWIG_From_long(static_cast< long >(result));
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28292 PyObject *resultobj = 0;
28293 wxString result;
28294
28295 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 result = wxPyApp::GetMacHelpMenuTitleName();
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 {
28303 #if wxUSE_UNICODE
28304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28305 #else
28306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28307 #endif
28308 }
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28316 PyObject *resultobj = 0;
28317 bool arg1 ;
28318 bool val1 ;
28319 int ecode1 = 0 ;
28320 PyObject * obj0 = 0 ;
28321 char * kwnames[] = {
28322 (char *) "val", NULL
28323 };
28324
28325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28326 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28327 if (!SWIG_IsOK(ecode1)) {
28328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28329 }
28330 arg1 = static_cast< bool >(val1);
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj = 0;
28346 long arg1 ;
28347 long val1 ;
28348 int ecode1 = 0 ;
28349 PyObject * obj0 = 0 ;
28350 char * kwnames[] = {
28351 (char *) "val", NULL
28352 };
28353
28354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28355 ecode1 = SWIG_AsVal_long(obj0, &val1);
28356 if (!SWIG_IsOK(ecode1)) {
28357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28358 }
28359 arg1 = static_cast< long >(val1);
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 wxPyApp::SetMacAboutMenuItemId(arg1);
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 resultobj = SWIG_Py_Void();
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28374 PyObject *resultobj = 0;
28375 long arg1 ;
28376 long val1 ;
28377 int ecode1 = 0 ;
28378 PyObject * obj0 = 0 ;
28379 char * kwnames[] = {
28380 (char *) "val", NULL
28381 };
28382
28383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28384 ecode1 = SWIG_AsVal_long(obj0, &val1);
28385 if (!SWIG_IsOK(ecode1)) {
28386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28387 }
28388 arg1 = static_cast< long >(val1);
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 resultobj = SWIG_Py_Void();
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28403 PyObject *resultobj = 0;
28404 long arg1 ;
28405 long val1 ;
28406 int ecode1 = 0 ;
28407 PyObject * obj0 = 0 ;
28408 char * kwnames[] = {
28409 (char *) "val", NULL
28410 };
28411
28412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28413 ecode1 = SWIG_AsVal_long(obj0, &val1);
28414 if (!SWIG_IsOK(ecode1)) {
28415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28416 }
28417 arg1 = static_cast< long >(val1);
28418 {
28419 PyThreadState* __tstate = wxPyBeginAllowThreads();
28420 wxPyApp::SetMacExitMenuItemId(arg1);
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 resultobj = SWIG_Py_Void();
28425 return resultobj;
28426 fail:
28427 return NULL;
28428 }
28429
28430
28431 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28432 PyObject *resultobj = 0;
28433 wxString *arg1 = 0 ;
28434 bool temp1 = false ;
28435 PyObject * obj0 = 0 ;
28436 char * kwnames[] = {
28437 (char *) "val", NULL
28438 };
28439
28440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28441 {
28442 arg1 = wxString_in_helper(obj0);
28443 if (arg1 == NULL) SWIG_fail;
28444 temp1 = true;
28445 }
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28449 wxPyEndAllowThreads(__tstate);
28450 if (PyErr_Occurred()) SWIG_fail;
28451 }
28452 resultobj = SWIG_Py_Void();
28453 {
28454 if (temp1)
28455 delete arg1;
28456 }
28457 return resultobj;
28458 fail:
28459 {
28460 if (temp1)
28461 delete arg1;
28462 }
28463 return NULL;
28464 }
28465
28466
28467 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28468 PyObject *resultobj = 0;
28469 wxPyApp *arg1 = (wxPyApp *) 0 ;
28470 void *argp1 = 0 ;
28471 int res1 = 0 ;
28472 PyObject *swig_obj[1] ;
28473
28474 if (!args) SWIG_fail;
28475 swig_obj[0] = args;
28476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28479 }
28480 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 (arg1)->_BootstrapApp();
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 resultobj = SWIG_Py_Void();
28488 return resultobj;
28489 fail:
28490 return NULL;
28491 }
28492
28493
28494 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28495 PyObject *resultobj = 0;
28496 int result;
28497
28498 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28499 {
28500 PyThreadState* __tstate = wxPyBeginAllowThreads();
28501 result = (int)wxPyApp::GetComCtl32Version();
28502 wxPyEndAllowThreads(__tstate);
28503 if (PyErr_Occurred()) SWIG_fail;
28504 }
28505 resultobj = SWIG_From_int(static_cast< int >(result));
28506 return resultobj;
28507 fail:
28508 return NULL;
28509 }
28510
28511
28512 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28513 PyObject *resultobj = 0;
28514 bool result;
28515
28516 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 result = (bool)wxPyApp_DisplayAvailable();
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 {
28524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28525 }
28526 return resultobj;
28527 fail:
28528 return NULL;
28529 }
28530
28531
28532 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28533 PyObject *obj;
28534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28535 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28536 return SWIG_Py_Void();
28537 }
28538
28539 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28540 return SWIG_Python_InitShadowInstance(args);
28541 }
28542
28543 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *resultobj = 0;
28545
28546 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28547 {
28548 PyThreadState* __tstate = wxPyBeginAllowThreads();
28549 wxExit();
28550 wxPyEndAllowThreads(__tstate);
28551 if (PyErr_Occurred()) SWIG_fail;
28552 }
28553 resultobj = SWIG_Py_Void();
28554 return resultobj;
28555 fail:
28556 return NULL;
28557 }
28558
28559
28560 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28561 PyObject *resultobj = 0;
28562 bool result;
28563
28564 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 result = (bool)wxYield();
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 {
28572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28573 }
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28581 PyObject *resultobj = 0;
28582 bool result;
28583
28584 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 result = (bool)wxYieldIfNeeded();
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 {
28592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28593 }
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28601 PyObject *resultobj = 0;
28602 wxWindow *arg1 = (wxWindow *) NULL ;
28603 bool arg2 = (bool) false ;
28604 bool result;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 bool val2 ;
28608 int ecode2 = 0 ;
28609 PyObject * obj0 = 0 ;
28610 PyObject * obj1 = 0 ;
28611 char * kwnames[] = {
28612 (char *) "win",(char *) "onlyIfNeeded", NULL
28613 };
28614
28615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28616 if (obj0) {
28617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28618 if (!SWIG_IsOK(res1)) {
28619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28620 }
28621 arg1 = reinterpret_cast< wxWindow * >(argp1);
28622 }
28623 if (obj1) {
28624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28625 if (!SWIG_IsOK(ecode2)) {
28626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28627 }
28628 arg2 = static_cast< bool >(val2);
28629 }
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 result = (bool)wxSafeYield(arg1,arg2);
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 {
28637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28638 }
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28646 PyObject *resultobj = 0;
28647
28648 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 wxWakeUpIdle();
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_Py_Void();
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28665 wxEvent *arg2 = 0 ;
28666 void *argp1 = 0 ;
28667 int res1 = 0 ;
28668 void *argp2 = 0 ;
28669 int res2 = 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 char * kwnames[] = {
28673 (char *) "dest",(char *) "event", NULL
28674 };
28675
28676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28680 }
28681 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28683 if (!SWIG_IsOK(res2)) {
28684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28685 }
28686 if (!argp2) {
28687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28688 }
28689 arg2 = reinterpret_cast< wxEvent * >(argp2);
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 wxPostEvent(arg1,*arg2);
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_Py_Void();
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28704 PyObject *resultobj = 0;
28705
28706 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 wxApp_CleanUp();
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_Py_Void();
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28721 PyObject *resultobj = 0;
28722 wxPyApp *result = 0 ;
28723
28724 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 result = (wxPyApp *)wxPyGetApp();
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 {
28732 resultobj = wxPyMake_wxObject(result, 0);
28733 }
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28741 PyObject *resultobj = 0;
28742 char *arg1 = (char *) 0 ;
28743 int res1 ;
28744 char *buf1 = 0 ;
28745 int alloc1 = 0 ;
28746 PyObject * obj0 = 0 ;
28747 char * kwnames[] = {
28748 (char *) "encoding", NULL
28749 };
28750
28751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28752 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28753 if (!SWIG_IsOK(res1)) {
28754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28755 }
28756 arg1 = buf1;
28757 {
28758 PyThreadState* __tstate = wxPyBeginAllowThreads();
28759 wxSetDefaultPyEncoding((char const *)arg1);
28760 wxPyEndAllowThreads(__tstate);
28761 if (PyErr_Occurred()) SWIG_fail;
28762 }
28763 resultobj = SWIG_Py_Void();
28764 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28765 return resultobj;
28766 fail:
28767 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28768 return NULL;
28769 }
28770
28771
28772 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28773 PyObject *resultobj = 0;
28774 char *result = 0 ;
28775
28776 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28777 {
28778 PyThreadState* __tstate = wxPyBeginAllowThreads();
28779 result = (char *)wxGetDefaultPyEncoding();
28780 wxPyEndAllowThreads(__tstate);
28781 if (PyErr_Occurred()) SWIG_fail;
28782 }
28783 resultobj = SWIG_FromCharPtr(result);
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28791 PyObject *resultobj = 0;
28792 wxEventLoop *result = 0 ;
28793
28794 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (wxEventLoop *)new wxEventLoop();
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28809 PyObject *resultobj = 0;
28810 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28811 void *argp1 = 0 ;
28812 int res1 = 0 ;
28813 PyObject *swig_obj[1] ;
28814
28815 if (!args) SWIG_fail;
28816 swig_obj[0] = args;
28817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28818 if (!SWIG_IsOK(res1)) {
28819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28820 }
28821 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28822 {
28823 PyThreadState* __tstate = wxPyBeginAllowThreads();
28824 delete arg1;
28825
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 resultobj = SWIG_Py_Void();
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28837 PyObject *resultobj = 0;
28838 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28839 int result;
28840 void *argp1 = 0 ;
28841 int res1 = 0 ;
28842 PyObject *swig_obj[1] ;
28843
28844 if (!args) SWIG_fail;
28845 swig_obj[0] = args;
28846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28847 if (!SWIG_IsOK(res1)) {
28848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28849 }
28850 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 result = (int)(arg1)->Run();
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_From_int(static_cast< int >(result));
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj = 0;
28866 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28867 int arg2 = (int) 0 ;
28868 void *argp1 = 0 ;
28869 int res1 = 0 ;
28870 int val2 ;
28871 int ecode2 = 0 ;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 char * kwnames[] = {
28875 (char *) "self",(char *) "rc", NULL
28876 };
28877
28878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28882 }
28883 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28884 if (obj1) {
28885 ecode2 = SWIG_AsVal_int(obj1, &val2);
28886 if (!SWIG_IsOK(ecode2)) {
28887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28888 }
28889 arg2 = static_cast< int >(val2);
28890 }
28891 {
28892 PyThreadState* __tstate = wxPyBeginAllowThreads();
28893 (arg1)->Exit(arg2);
28894 wxPyEndAllowThreads(__tstate);
28895 if (PyErr_Occurred()) SWIG_fail;
28896 }
28897 resultobj = SWIG_Py_Void();
28898 return resultobj;
28899 fail:
28900 return NULL;
28901 }
28902
28903
28904 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28905 PyObject *resultobj = 0;
28906 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28907 bool result;
28908 void *argp1 = 0 ;
28909 int res1 = 0 ;
28910 PyObject *swig_obj[1] ;
28911
28912 if (!args) SWIG_fail;
28913 swig_obj[0] = args;
28914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28915 if (!SWIG_IsOK(res1)) {
28916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28917 }
28918 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28919 {
28920 PyThreadState* __tstate = wxPyBeginAllowThreads();
28921 result = (bool)((wxEventLoop const *)arg1)->Pending();
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 {
28926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28927 }
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28935 PyObject *resultobj = 0;
28936 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28937 bool result;
28938 void *argp1 = 0 ;
28939 int res1 = 0 ;
28940 PyObject *swig_obj[1] ;
28941
28942 if (!args) SWIG_fail;
28943 swig_obj[0] = args;
28944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28945 if (!SWIG_IsOK(res1)) {
28946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28947 }
28948 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 result = (bool)(arg1)->Dispatch();
28952 wxPyEndAllowThreads(__tstate);
28953 if (PyErr_Occurred()) SWIG_fail;
28954 }
28955 {
28956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28957 }
28958 return resultobj;
28959 fail:
28960 return NULL;
28961 }
28962
28963
28964 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28965 PyObject *resultobj = 0;
28966 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28967 bool result;
28968 void *argp1 = 0 ;
28969 int res1 = 0 ;
28970 PyObject *swig_obj[1] ;
28971
28972 if (!args) SWIG_fail;
28973 swig_obj[0] = args;
28974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28975 if (!SWIG_IsOK(res1)) {
28976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28977 }
28978 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 {
28986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28987 }
28988 return resultobj;
28989 fail:
28990 return NULL;
28991 }
28992
28993
28994 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28995 PyObject *resultobj = 0;
28996 wxEventLoop *result = 0 ;
28997
28998 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 result = (wxEventLoop *)wxEventLoop::GetActive();
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29006 return resultobj;
29007 fail:
29008 return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29013 PyObject *resultobj = 0;
29014 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29015 void *argp1 = 0 ;
29016 int res1 = 0 ;
29017 PyObject * obj0 = 0 ;
29018 char * kwnames[] = {
29019 (char *) "loop", NULL
29020 };
29021
29022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29026 }
29027 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 wxEventLoop::SetActive(arg1);
29031 wxPyEndAllowThreads(__tstate);
29032 if (PyErr_Occurred()) SWIG_fail;
29033 }
29034 resultobj = SWIG_Py_Void();
29035 return resultobj;
29036 fail:
29037 return NULL;
29038 }
29039
29040
29041 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29042 PyObject *obj;
29043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29044 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29045 return SWIG_Py_Void();
29046 }
29047
29048 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29049 return SWIG_Python_InitShadowInstance(args);
29050 }
29051
29052 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj = 0;
29054 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29055 wxEventLoopActivator *result = 0 ;
29056 void *argp1 = 0 ;
29057 int res1 = 0 ;
29058 PyObject * obj0 = 0 ;
29059 char * kwnames[] = {
29060 (char *) "evtLoop", NULL
29061 };
29062
29063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29065 if (!SWIG_IsOK(res1)) {
29066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29067 }
29068 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29083 PyObject *resultobj = 0;
29084 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29085 void *argp1 = 0 ;
29086 int res1 = 0 ;
29087 PyObject *swig_obj[1] ;
29088
29089 if (!args) SWIG_fail;
29090 swig_obj[0] = args;
29091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29092 if (!SWIG_IsOK(res1)) {
29093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29094 }
29095 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29096 {
29097 PyThreadState* __tstate = wxPyBeginAllowThreads();
29098 delete arg1;
29099
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 resultobj = SWIG_Py_Void();
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29111 PyObject *obj;
29112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29113 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29114 return SWIG_Py_Void();
29115 }
29116
29117 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29118 return SWIG_Python_InitShadowInstance(args);
29119 }
29120
29121 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = 0;
29123 int arg1 = (int) 0 ;
29124 int arg2 = (int) 0 ;
29125 int arg3 = (int) 0 ;
29126 wxAcceleratorEntry *result = 0 ;
29127 int val1 ;
29128 int ecode1 = 0 ;
29129 int val2 ;
29130 int ecode2 = 0 ;
29131 int val3 ;
29132 int ecode3 = 0 ;
29133 PyObject * obj0 = 0 ;
29134 PyObject * obj1 = 0 ;
29135 PyObject * obj2 = 0 ;
29136 char * kwnames[] = {
29137 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29138 };
29139
29140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29141 if (obj0) {
29142 ecode1 = SWIG_AsVal_int(obj0, &val1);
29143 if (!SWIG_IsOK(ecode1)) {
29144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29145 }
29146 arg1 = static_cast< int >(val1);
29147 }
29148 if (obj1) {
29149 ecode2 = SWIG_AsVal_int(obj1, &val2);
29150 if (!SWIG_IsOK(ecode2)) {
29151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29152 }
29153 arg2 = static_cast< int >(val2);
29154 }
29155 if (obj2) {
29156 ecode3 = SWIG_AsVal_int(obj2, &val3);
29157 if (!SWIG_IsOK(ecode3)) {
29158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29159 }
29160 arg3 = static_cast< int >(val3);
29161 }
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29176 PyObject *resultobj = 0;
29177 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29178 void *argp1 = 0 ;
29179 int res1 = 0 ;
29180 PyObject *swig_obj[1] ;
29181
29182 if (!args) SWIG_fail;
29183 swig_obj[0] = args;
29184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29187 }
29188 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 delete arg1;
29192
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_Py_Void();
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj = 0;
29205 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29206 int arg2 ;
29207 int arg3 ;
29208 int arg4 ;
29209 void *argp1 = 0 ;
29210 int res1 = 0 ;
29211 int val2 ;
29212 int ecode2 = 0 ;
29213 int val3 ;
29214 int ecode3 = 0 ;
29215 int val4 ;
29216 int ecode4 = 0 ;
29217 PyObject * obj0 = 0 ;
29218 PyObject * obj1 = 0 ;
29219 PyObject * obj2 = 0 ;
29220 PyObject * obj3 = 0 ;
29221 char * kwnames[] = {
29222 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29223 };
29224
29225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29227 if (!SWIG_IsOK(res1)) {
29228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29229 }
29230 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29231 ecode2 = SWIG_AsVal_int(obj1, &val2);
29232 if (!SWIG_IsOK(ecode2)) {
29233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29234 }
29235 arg2 = static_cast< int >(val2);
29236 ecode3 = SWIG_AsVal_int(obj2, &val3);
29237 if (!SWIG_IsOK(ecode3)) {
29238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29239 }
29240 arg3 = static_cast< int >(val3);
29241 ecode4 = SWIG_AsVal_int(obj3, &val4);
29242 if (!SWIG_IsOK(ecode4)) {
29243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29244 }
29245 arg4 = static_cast< int >(val4);
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 (arg1)->Set(arg2,arg3,arg4);
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_Py_Void();
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29260 PyObject *resultobj = 0;
29261 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29262 int result;
29263 void *argp1 = 0 ;
29264 int res1 = 0 ;
29265 PyObject *swig_obj[1] ;
29266
29267 if (!args) SWIG_fail;
29268 swig_obj[0] = args;
29269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29270 if (!SWIG_IsOK(res1)) {
29271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29272 }
29273 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29274 {
29275 PyThreadState* __tstate = wxPyBeginAllowThreads();
29276 result = (int)(arg1)->GetFlags();
29277 wxPyEndAllowThreads(__tstate);
29278 if (PyErr_Occurred()) SWIG_fail;
29279 }
29280 resultobj = SWIG_From_int(static_cast< int >(result));
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29288 PyObject *resultobj = 0;
29289 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29290 int result;
29291 void *argp1 = 0 ;
29292 int res1 = 0 ;
29293 PyObject *swig_obj[1] ;
29294
29295 if (!args) SWIG_fail;
29296 swig_obj[0] = args;
29297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29298 if (!SWIG_IsOK(res1)) {
29299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29300 }
29301 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 result = (int)(arg1)->GetKeyCode();
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 resultobj = SWIG_From_int(static_cast< int >(result));
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29316 PyObject *resultobj = 0;
29317 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29318 int result;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 PyObject *swig_obj[1] ;
29322
29323 if (!args) SWIG_fail;
29324 swig_obj[0] = args;
29325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29328 }
29329 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = (int)(arg1)->GetCommand();
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 resultobj = SWIG_From_int(static_cast< int >(result));
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29344 PyObject *obj;
29345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29346 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29347 return SWIG_Py_Void();
29348 }
29349
29350 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29351 return SWIG_Python_InitShadowInstance(args);
29352 }
29353
29354 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29355 PyObject *resultobj = 0;
29356 int arg1 ;
29357 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29358 wxAcceleratorTable *result = 0 ;
29359 PyObject * obj0 = 0 ;
29360 char * kwnames[] = {
29361 (char *) "n", NULL
29362 };
29363
29364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29365 {
29366 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29367 if (arg2) arg1 = PyList_Size(obj0);
29368 else arg1 = 0;
29369 }
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29373 wxPyEndAllowThreads(__tstate);
29374 if (PyErr_Occurred()) SWIG_fail;
29375 }
29376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29384 PyObject *resultobj = 0;
29385 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29386 void *argp1 = 0 ;
29387 int res1 = 0 ;
29388 PyObject *swig_obj[1] ;
29389
29390 if (!args) SWIG_fail;
29391 swig_obj[0] = args;
29392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29393 if (!SWIG_IsOK(res1)) {
29394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29395 }
29396 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 delete arg1;
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 resultobj = SWIG_Py_Void();
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29412 PyObject *resultobj = 0;
29413 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29414 bool result;
29415 void *argp1 = 0 ;
29416 int res1 = 0 ;
29417 PyObject *swig_obj[1] ;
29418
29419 if (!args) SWIG_fail;
29420 swig_obj[0] = args;
29421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29422 if (!SWIG_IsOK(res1)) {
29423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29424 }
29425 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 {
29433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29434 }
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29442 PyObject *obj;
29443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29444 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29445 return SWIG_Py_Void();
29446 }
29447
29448 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29449 return SWIG_Python_InitShadowInstance(args);
29450 }
29451
29452 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29453 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29454 return 1;
29455 }
29456
29457
29458 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29459 PyObject *pyobj = 0;
29460
29461 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29462 return pyobj;
29463 }
29464
29465
29466 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29467 PyObject *resultobj = 0;
29468 wxString *arg1 = 0 ;
29469 wxAcceleratorEntry *result = 0 ;
29470 bool temp1 = false ;
29471 PyObject * obj0 = 0 ;
29472 char * kwnames[] = {
29473 (char *) "label", NULL
29474 };
29475
29476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29477 {
29478 arg1 = wxString_in_helper(obj0);
29479 if (arg1 == NULL) SWIG_fail;
29480 temp1 = true;
29481 }
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29489 {
29490 if (temp1)
29491 delete arg1;
29492 }
29493 return resultobj;
29494 fail:
29495 {
29496 if (temp1)
29497 delete arg1;
29498 }
29499 return NULL;
29500 }
29501
29502
29503 SWIGINTERN int PanelNameStr_set(PyObject *) {
29504 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29505 return 1;
29506 }
29507
29508
29509 SWIGINTERN PyObject *PanelNameStr_get(void) {
29510 PyObject *pyobj = 0;
29511
29512 {
29513 #if wxUSE_UNICODE
29514 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29515 #else
29516 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29517 #endif
29518 }
29519 return pyobj;
29520 }
29521
29522
29523 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29524 PyObject *resultobj = 0;
29525 wxVisualAttributes *result = 0 ;
29526
29527 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = (wxVisualAttributes *)new_wxVisualAttributes();
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29542 PyObject *resultobj = 0;
29543 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29544 void *argp1 = 0 ;
29545 int res1 = 0 ;
29546 PyObject *swig_obj[1] ;
29547
29548 if (!args) SWIG_fail;
29549 swig_obj[0] = args;
29550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29551 if (!SWIG_IsOK(res1)) {
29552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29553 }
29554 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 delete_wxVisualAttributes(arg1);
29558
29559 wxPyEndAllowThreads(__tstate);
29560 if (PyErr_Occurred()) SWIG_fail;
29561 }
29562 resultobj = SWIG_Py_Void();
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29570 PyObject *resultobj = 0;
29571 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29572 wxFont *arg2 = (wxFont *) 0 ;
29573 void *argp1 = 0 ;
29574 int res1 = 0 ;
29575 void *argp2 = 0 ;
29576 int res2 = 0 ;
29577 PyObject *swig_obj[2] ;
29578
29579 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29581 if (!SWIG_IsOK(res1)) {
29582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29583 }
29584 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29586 if (!SWIG_IsOK(res2)) {
29587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29588 }
29589 arg2 = reinterpret_cast< wxFont * >(argp2);
29590 if (arg1) (arg1)->font = *arg2;
29591
29592 resultobj = SWIG_Py_Void();
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29602 wxFont *result = 0 ;
29603 void *argp1 = 0 ;
29604 int res1 = 0 ;
29605 PyObject *swig_obj[1] ;
29606
29607 if (!args) SWIG_fail;
29608 swig_obj[0] = args;
29609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29612 }
29613 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29614 result = (wxFont *)& ((arg1)->font);
29615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29616 return resultobj;
29617 fail:
29618 return NULL;
29619 }
29620
29621
29622 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29623 PyObject *resultobj = 0;
29624 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29625 wxColour *arg2 = (wxColour *) 0 ;
29626 void *argp1 = 0 ;
29627 int res1 = 0 ;
29628 void *argp2 = 0 ;
29629 int res2 = 0 ;
29630 PyObject *swig_obj[2] ;
29631
29632 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29634 if (!SWIG_IsOK(res1)) {
29635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29636 }
29637 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29639 if (!SWIG_IsOK(res2)) {
29640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29641 }
29642 arg2 = reinterpret_cast< wxColour * >(argp2);
29643 if (arg1) (arg1)->colFg = *arg2;
29644
29645 resultobj = SWIG_Py_Void();
29646 return resultobj;
29647 fail:
29648 return NULL;
29649 }
29650
29651
29652 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29653 PyObject *resultobj = 0;
29654 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29655 wxColour *result = 0 ;
29656 void *argp1 = 0 ;
29657 int res1 = 0 ;
29658 PyObject *swig_obj[1] ;
29659
29660 if (!args) SWIG_fail;
29661 swig_obj[0] = args;
29662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29663 if (!SWIG_IsOK(res1)) {
29664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29665 }
29666 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29667 result = (wxColour *)& ((arg1)->colFg);
29668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29676 PyObject *resultobj = 0;
29677 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29678 wxColour *arg2 = (wxColour *) 0 ;
29679 void *argp1 = 0 ;
29680 int res1 = 0 ;
29681 void *argp2 = 0 ;
29682 int res2 = 0 ;
29683 PyObject *swig_obj[2] ;
29684
29685 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29687 if (!SWIG_IsOK(res1)) {
29688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29689 }
29690 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29691 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29692 if (!SWIG_IsOK(res2)) {
29693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29694 }
29695 arg2 = reinterpret_cast< wxColour * >(argp2);
29696 if (arg1) (arg1)->colBg = *arg2;
29697
29698 resultobj = SWIG_Py_Void();
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *resultobj = 0;
29707 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29708 wxColour *result = 0 ;
29709 void *argp1 = 0 ;
29710 int res1 = 0 ;
29711 PyObject *swig_obj[1] ;
29712
29713 if (!args) SWIG_fail;
29714 swig_obj[0] = args;
29715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29716 if (!SWIG_IsOK(res1)) {
29717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29718 }
29719 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29720 result = (wxColour *)& ((arg1)->colBg);
29721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29722 return resultobj;
29723 fail:
29724 return NULL;
29725 }
29726
29727
29728 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29729 PyObject *obj;
29730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29731 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29732 return SWIG_Py_Void();
29733 }
29734
29735 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 return SWIG_Python_InitShadowInstance(args);
29737 }
29738
29739 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29740 PyObject *resultobj = 0;
29741 wxWindow *arg1 = (wxWindow *) 0 ;
29742 int arg2 = (int) (int)-1 ;
29743 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29744 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29745 wxSize const &arg4_defvalue = wxDefaultSize ;
29746 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29747 long arg5 = (long) 0 ;
29748 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29749 wxString *arg6 = (wxString *) &arg6_defvalue ;
29750 wxWindow *result = 0 ;
29751 void *argp1 = 0 ;
29752 int res1 = 0 ;
29753 int val2 ;
29754 int ecode2 = 0 ;
29755 wxPoint temp3 ;
29756 wxSize temp4 ;
29757 long val5 ;
29758 int ecode5 = 0 ;
29759 bool temp6 = false ;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 PyObject * obj2 = 0 ;
29763 PyObject * obj3 = 0 ;
29764 PyObject * obj4 = 0 ;
29765 PyObject * obj5 = 0 ;
29766 char * kwnames[] = {
29767 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29768 };
29769
29770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29772 if (!SWIG_IsOK(res1)) {
29773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29774 }
29775 arg1 = reinterpret_cast< wxWindow * >(argp1);
29776 if (obj1) {
29777 ecode2 = SWIG_AsVal_int(obj1, &val2);
29778 if (!SWIG_IsOK(ecode2)) {
29779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29780 }
29781 arg2 = static_cast< int >(val2);
29782 }
29783 if (obj2) {
29784 {
29785 arg3 = &temp3;
29786 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29787 }
29788 }
29789 if (obj3) {
29790 {
29791 arg4 = &temp4;
29792 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29793 }
29794 }
29795 if (obj4) {
29796 ecode5 = SWIG_AsVal_long(obj4, &val5);
29797 if (!SWIG_IsOK(ecode5)) {
29798 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29799 }
29800 arg5 = static_cast< long >(val5);
29801 }
29802 if (obj5) {
29803 {
29804 arg6 = wxString_in_helper(obj5);
29805 if (arg6 == NULL) SWIG_fail;
29806 temp6 = true;
29807 }
29808 }
29809 {
29810 if (!wxPyCheckForApp()) SWIG_fail;
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29817 {
29818 if (temp6)
29819 delete arg6;
29820 }
29821 return resultobj;
29822 fail:
29823 {
29824 if (temp6)
29825 delete arg6;
29826 }
29827 return NULL;
29828 }
29829
29830
29831 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29832 PyObject *resultobj = 0;
29833 wxWindow *result = 0 ;
29834
29835 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29836 {
29837 if (!wxPyCheckForApp()) SWIG_fail;
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 result = (wxWindow *)new wxWindow();
29840 wxPyEndAllowThreads(__tstate);
29841 if (PyErr_Occurred()) SWIG_fail;
29842 }
29843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29844 return resultobj;
29845 fail:
29846 return NULL;
29847 }
29848
29849
29850 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29851 PyObject *resultobj = 0;
29852 wxWindow *arg1 = (wxWindow *) 0 ;
29853 wxWindow *arg2 = (wxWindow *) 0 ;
29854 int arg3 = (int) (int)-1 ;
29855 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29856 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29857 wxSize const &arg5_defvalue = wxDefaultSize ;
29858 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29859 long arg6 = (long) 0 ;
29860 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29861 wxString *arg7 = (wxString *) &arg7_defvalue ;
29862 bool result;
29863 void *argp1 = 0 ;
29864 int res1 = 0 ;
29865 void *argp2 = 0 ;
29866 int res2 = 0 ;
29867 int val3 ;
29868 int ecode3 = 0 ;
29869 wxPoint temp4 ;
29870 wxSize temp5 ;
29871 long val6 ;
29872 int ecode6 = 0 ;
29873 bool temp7 = false ;
29874 PyObject * obj0 = 0 ;
29875 PyObject * obj1 = 0 ;
29876 PyObject * obj2 = 0 ;
29877 PyObject * obj3 = 0 ;
29878 PyObject * obj4 = 0 ;
29879 PyObject * obj5 = 0 ;
29880 PyObject * obj6 = 0 ;
29881 char * kwnames[] = {
29882 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29883 };
29884
29885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29887 if (!SWIG_IsOK(res1)) {
29888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29889 }
29890 arg1 = reinterpret_cast< wxWindow * >(argp1);
29891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29892 if (!SWIG_IsOK(res2)) {
29893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29894 }
29895 arg2 = reinterpret_cast< wxWindow * >(argp2);
29896 if (obj2) {
29897 ecode3 = SWIG_AsVal_int(obj2, &val3);
29898 if (!SWIG_IsOK(ecode3)) {
29899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29900 }
29901 arg3 = static_cast< int >(val3);
29902 }
29903 if (obj3) {
29904 {
29905 arg4 = &temp4;
29906 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29907 }
29908 }
29909 if (obj4) {
29910 {
29911 arg5 = &temp5;
29912 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29913 }
29914 }
29915 if (obj5) {
29916 ecode6 = SWIG_AsVal_long(obj5, &val6);
29917 if (!SWIG_IsOK(ecode6)) {
29918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29919 }
29920 arg6 = static_cast< long >(val6);
29921 }
29922 if (obj6) {
29923 {
29924 arg7 = wxString_in_helper(obj6);
29925 if (arg7 == NULL) SWIG_fail;
29926 temp7 = true;
29927 }
29928 }
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29937 }
29938 {
29939 if (temp7)
29940 delete arg7;
29941 }
29942 return resultobj;
29943 fail:
29944 {
29945 if (temp7)
29946 delete arg7;
29947 }
29948 return NULL;
29949 }
29950
29951
29952 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj = 0;
29954 wxWindow *arg1 = (wxWindow *) 0 ;
29955 bool arg2 = (bool) false ;
29956 bool result;
29957 void *argp1 = 0 ;
29958 int res1 = 0 ;
29959 bool val2 ;
29960 int ecode2 = 0 ;
29961 PyObject * obj0 = 0 ;
29962 PyObject * obj1 = 0 ;
29963 char * kwnames[] = {
29964 (char *) "self",(char *) "force", NULL
29965 };
29966
29967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29969 if (!SWIG_IsOK(res1)) {
29970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29971 }
29972 arg1 = reinterpret_cast< wxWindow * >(argp1);
29973 if (obj1) {
29974 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29975 if (!SWIG_IsOK(ecode2)) {
29976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29977 }
29978 arg2 = static_cast< bool >(val2);
29979 }
29980 {
29981 PyThreadState* __tstate = wxPyBeginAllowThreads();
29982 result = (bool)(arg1)->Close(arg2);
29983 wxPyEndAllowThreads(__tstate);
29984 if (PyErr_Occurred()) SWIG_fail;
29985 }
29986 {
29987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29988 }
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *resultobj = 0;
29997 wxWindow *arg1 = (wxWindow *) 0 ;
29998 bool result;
29999 void *argp1 = 0 ;
30000 int res1 = 0 ;
30001 PyObject *swig_obj[1] ;
30002
30003 if (!args) SWIG_fail;
30004 swig_obj[0] = args;
30005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30006 if (!SWIG_IsOK(res1)) {
30007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30008 }
30009 arg1 = reinterpret_cast< wxWindow * >(argp1);
30010 {
30011 PyThreadState* __tstate = wxPyBeginAllowThreads();
30012 result = (bool)(arg1)->Destroy();
30013 wxPyEndAllowThreads(__tstate);
30014 if (PyErr_Occurred()) SWIG_fail;
30015 }
30016 {
30017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30018 }
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30026 PyObject *resultobj = 0;
30027 wxWindow *arg1 = (wxWindow *) 0 ;
30028 bool result;
30029 void *argp1 = 0 ;
30030 int res1 = 0 ;
30031 PyObject *swig_obj[1] ;
30032
30033 if (!args) SWIG_fail;
30034 swig_obj[0] = args;
30035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30036 if (!SWIG_IsOK(res1)) {
30037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30038 }
30039 arg1 = reinterpret_cast< wxWindow * >(argp1);
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 result = (bool)(arg1)->DestroyChildren();
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 {
30047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30048 }
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30056 PyObject *resultobj = 0;
30057 wxWindow *arg1 = (wxWindow *) 0 ;
30058 bool result;
30059 void *argp1 = 0 ;
30060 int res1 = 0 ;
30061 PyObject *swig_obj[1] ;
30062
30063 if (!args) SWIG_fail;
30064 swig_obj[0] = args;
30065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30066 if (!SWIG_IsOK(res1)) {
30067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30068 }
30069 arg1 = reinterpret_cast< wxWindow * >(argp1);
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30073 wxPyEndAllowThreads(__tstate);
30074 if (PyErr_Occurred()) SWIG_fail;
30075 }
30076 {
30077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30078 }
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30086 PyObject *resultobj = 0;
30087 wxWindow *arg1 = (wxWindow *) 0 ;
30088 wxString *arg2 = 0 ;
30089 void *argp1 = 0 ;
30090 int res1 = 0 ;
30091 bool temp2 = false ;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 char * kwnames[] = {
30095 (char *) "self",(char *) "label", NULL
30096 };
30097
30098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30100 if (!SWIG_IsOK(res1)) {
30101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30102 }
30103 arg1 = reinterpret_cast< wxWindow * >(argp1);
30104 {
30105 arg2 = wxString_in_helper(obj1);
30106 if (arg2 == NULL) SWIG_fail;
30107 temp2 = true;
30108 }
30109 {
30110 PyThreadState* __tstate = wxPyBeginAllowThreads();
30111 (arg1)->SetLabel((wxString const &)*arg2);
30112 wxPyEndAllowThreads(__tstate);
30113 if (PyErr_Occurred()) SWIG_fail;
30114 }
30115 resultobj = SWIG_Py_Void();
30116 {
30117 if (temp2)
30118 delete arg2;
30119 }
30120 return resultobj;
30121 fail:
30122 {
30123 if (temp2)
30124 delete arg2;
30125 }
30126 return NULL;
30127 }
30128
30129
30130 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30131 PyObject *resultobj = 0;
30132 wxWindow *arg1 = (wxWindow *) 0 ;
30133 wxString result;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 PyObject *swig_obj[1] ;
30137
30138 if (!args) SWIG_fail;
30139 swig_obj[0] = args;
30140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30141 if (!SWIG_IsOK(res1)) {
30142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30143 }
30144 arg1 = reinterpret_cast< wxWindow * >(argp1);
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 result = ((wxWindow const *)arg1)->GetLabel();
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 {
30152 #if wxUSE_UNICODE
30153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30154 #else
30155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30156 #endif
30157 }
30158 return resultobj;
30159 fail:
30160 return NULL;
30161 }
30162
30163
30164 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30165 PyObject *resultobj = 0;
30166 wxWindow *arg1 = (wxWindow *) 0 ;
30167 wxString *arg2 = 0 ;
30168 void *argp1 = 0 ;
30169 int res1 = 0 ;
30170 bool temp2 = false ;
30171 PyObject * obj0 = 0 ;
30172 PyObject * obj1 = 0 ;
30173 char * kwnames[] = {
30174 (char *) "self",(char *) "name", NULL
30175 };
30176
30177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30179 if (!SWIG_IsOK(res1)) {
30180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30181 }
30182 arg1 = reinterpret_cast< wxWindow * >(argp1);
30183 {
30184 arg2 = wxString_in_helper(obj1);
30185 if (arg2 == NULL) SWIG_fail;
30186 temp2 = true;
30187 }
30188 {
30189 PyThreadState* __tstate = wxPyBeginAllowThreads();
30190 (arg1)->SetName((wxString const &)*arg2);
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 resultobj = SWIG_Py_Void();
30195 {
30196 if (temp2)
30197 delete arg2;
30198 }
30199 return resultobj;
30200 fail:
30201 {
30202 if (temp2)
30203 delete arg2;
30204 }
30205 return NULL;
30206 }
30207
30208
30209 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30210 PyObject *resultobj = 0;
30211 wxWindow *arg1 = (wxWindow *) 0 ;
30212 wxString result;
30213 void *argp1 = 0 ;
30214 int res1 = 0 ;
30215 PyObject *swig_obj[1] ;
30216
30217 if (!args) SWIG_fail;
30218 swig_obj[0] = args;
30219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30220 if (!SWIG_IsOK(res1)) {
30221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30222 }
30223 arg1 = reinterpret_cast< wxWindow * >(argp1);
30224 {
30225 PyThreadState* __tstate = wxPyBeginAllowThreads();
30226 result = ((wxWindow const *)arg1)->GetName();
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 {
30231 #if wxUSE_UNICODE
30232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30233 #else
30234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30235 #endif
30236 }
30237 return resultobj;
30238 fail:
30239 return NULL;
30240 }
30241
30242
30243 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30244 PyObject *resultobj = 0;
30245 wxWindow *arg1 = (wxWindow *) 0 ;
30246 wxWindowVariant arg2 ;
30247 void *argp1 = 0 ;
30248 int res1 = 0 ;
30249 int val2 ;
30250 int ecode2 = 0 ;
30251 PyObject * obj0 = 0 ;
30252 PyObject * obj1 = 0 ;
30253 char * kwnames[] = {
30254 (char *) "self",(char *) "variant", NULL
30255 };
30256
30257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30259 if (!SWIG_IsOK(res1)) {
30260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30261 }
30262 arg1 = reinterpret_cast< wxWindow * >(argp1);
30263 ecode2 = SWIG_AsVal_int(obj1, &val2);
30264 if (!SWIG_IsOK(ecode2)) {
30265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30266 }
30267 arg2 = static_cast< wxWindowVariant >(val2);
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 (arg1)->SetWindowVariant(arg2);
30271 wxPyEndAllowThreads(__tstate);
30272 if (PyErr_Occurred()) SWIG_fail;
30273 }
30274 resultobj = SWIG_Py_Void();
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30282 PyObject *resultobj = 0;
30283 wxWindow *arg1 = (wxWindow *) 0 ;
30284 wxWindowVariant result;
30285 void *argp1 = 0 ;
30286 int res1 = 0 ;
30287 PyObject *swig_obj[1] ;
30288
30289 if (!args) SWIG_fail;
30290 swig_obj[0] = args;
30291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30292 if (!SWIG_IsOK(res1)) {
30293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30294 }
30295 arg1 = reinterpret_cast< wxWindow * >(argp1);
30296 {
30297 PyThreadState* __tstate = wxPyBeginAllowThreads();
30298 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30299 wxPyEndAllowThreads(__tstate);
30300 if (PyErr_Occurred()) SWIG_fail;
30301 }
30302 resultobj = SWIG_From_int(static_cast< int >(result));
30303 return resultobj;
30304 fail:
30305 return NULL;
30306 }
30307
30308
30309 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30310 PyObject *resultobj = 0;
30311 wxWindow *arg1 = (wxWindow *) 0 ;
30312 int arg2 ;
30313 void *argp1 = 0 ;
30314 int res1 = 0 ;
30315 int val2 ;
30316 int ecode2 = 0 ;
30317 PyObject * obj0 = 0 ;
30318 PyObject * obj1 = 0 ;
30319 char * kwnames[] = {
30320 (char *) "self",(char *) "winid", NULL
30321 };
30322
30323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30325 if (!SWIG_IsOK(res1)) {
30326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30327 }
30328 arg1 = reinterpret_cast< wxWindow * >(argp1);
30329 ecode2 = SWIG_AsVal_int(obj1, &val2);
30330 if (!SWIG_IsOK(ecode2)) {
30331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30332 }
30333 arg2 = static_cast< int >(val2);
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 (arg1)->SetId(arg2);
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 resultobj = SWIG_Py_Void();
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 wxWindow *arg1 = (wxWindow *) 0 ;
30350 int result;
30351 void *argp1 = 0 ;
30352 int res1 = 0 ;
30353 PyObject *swig_obj[1] ;
30354
30355 if (!args) SWIG_fail;
30356 swig_obj[0] = args;
30357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30358 if (!SWIG_IsOK(res1)) {
30359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30360 }
30361 arg1 = reinterpret_cast< wxWindow * >(argp1);
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 result = (int)((wxWindow const *)arg1)->GetId();
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_From_int(static_cast< int >(result));
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30376 PyObject *resultobj = 0;
30377 int result;
30378
30379 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30380 {
30381 PyThreadState* __tstate = wxPyBeginAllowThreads();
30382 result = (int)wxWindow::NewControlId();
30383 wxPyEndAllowThreads(__tstate);
30384 if (PyErr_Occurred()) SWIG_fail;
30385 }
30386 resultobj = SWIG_From_int(static_cast< int >(result));
30387 return resultobj;
30388 fail:
30389 return NULL;
30390 }
30391
30392
30393 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30394 PyObject *resultobj = 0;
30395 int arg1 ;
30396 int result;
30397 int val1 ;
30398 int ecode1 = 0 ;
30399 PyObject * obj0 = 0 ;
30400 char * kwnames[] = {
30401 (char *) "winid", NULL
30402 };
30403
30404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30405 ecode1 = SWIG_AsVal_int(obj0, &val1);
30406 if (!SWIG_IsOK(ecode1)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30408 }
30409 arg1 = static_cast< int >(val1);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 result = (int)wxWindow::NextControlId(arg1);
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 resultobj = SWIG_From_int(static_cast< int >(result));
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj = 0;
30425 int arg1 ;
30426 int result;
30427 int val1 ;
30428 int ecode1 = 0 ;
30429 PyObject * obj0 = 0 ;
30430 char * kwnames[] = {
30431 (char *) "winid", NULL
30432 };
30433
30434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30435 ecode1 = SWIG_AsVal_int(obj0, &val1);
30436 if (!SWIG_IsOK(ecode1)) {
30437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30438 }
30439 arg1 = static_cast< int >(val1);
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 result = (int)wxWindow::PrevControlId(arg1);
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 resultobj = SWIG_From_int(static_cast< int >(result));
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30454 PyObject *resultobj = 0;
30455 wxWindow *arg1 = (wxWindow *) 0 ;
30456 wxSize *arg2 = 0 ;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 wxSize temp2 ;
30460 PyObject * obj0 = 0 ;
30461 PyObject * obj1 = 0 ;
30462 char * kwnames[] = {
30463 (char *) "self",(char *) "size", NULL
30464 };
30465
30466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30468 if (!SWIG_IsOK(res1)) {
30469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30470 }
30471 arg1 = reinterpret_cast< wxWindow * >(argp1);
30472 {
30473 arg2 = &temp2;
30474 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30475 }
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 (arg1)->SetSize((wxSize const &)*arg2);
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_Py_Void();
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj = 0;
30491 wxWindow *arg1 = (wxWindow *) 0 ;
30492 int arg2 ;
30493 int arg3 ;
30494 int arg4 ;
30495 int arg5 ;
30496 int arg6 = (int) wxSIZE_AUTO ;
30497 void *argp1 = 0 ;
30498 int res1 = 0 ;
30499 int val2 ;
30500 int ecode2 = 0 ;
30501 int val3 ;
30502 int ecode3 = 0 ;
30503 int val4 ;
30504 int ecode4 = 0 ;
30505 int val5 ;
30506 int ecode5 = 0 ;
30507 int val6 ;
30508 int ecode6 = 0 ;
30509 PyObject * obj0 = 0 ;
30510 PyObject * obj1 = 0 ;
30511 PyObject * obj2 = 0 ;
30512 PyObject * obj3 = 0 ;
30513 PyObject * obj4 = 0 ;
30514 PyObject * obj5 = 0 ;
30515 char * kwnames[] = {
30516 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30517 };
30518
30519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30523 }
30524 arg1 = reinterpret_cast< wxWindow * >(argp1);
30525 ecode2 = SWIG_AsVal_int(obj1, &val2);
30526 if (!SWIG_IsOK(ecode2)) {
30527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30528 }
30529 arg2 = static_cast< int >(val2);
30530 ecode3 = SWIG_AsVal_int(obj2, &val3);
30531 if (!SWIG_IsOK(ecode3)) {
30532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30533 }
30534 arg3 = static_cast< int >(val3);
30535 ecode4 = SWIG_AsVal_int(obj3, &val4);
30536 if (!SWIG_IsOK(ecode4)) {
30537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30538 }
30539 arg4 = static_cast< int >(val4);
30540 ecode5 = SWIG_AsVal_int(obj4, &val5);
30541 if (!SWIG_IsOK(ecode5)) {
30542 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30543 }
30544 arg5 = static_cast< int >(val5);
30545 if (obj5) {
30546 ecode6 = SWIG_AsVal_int(obj5, &val6);
30547 if (!SWIG_IsOK(ecode6)) {
30548 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30549 }
30550 arg6 = static_cast< int >(val6);
30551 }
30552 {
30553 PyThreadState* __tstate = wxPyBeginAllowThreads();
30554 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30555 wxPyEndAllowThreads(__tstate);
30556 if (PyErr_Occurred()) SWIG_fail;
30557 }
30558 resultobj = SWIG_Py_Void();
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30566 PyObject *resultobj = 0;
30567 wxWindow *arg1 = (wxWindow *) 0 ;
30568 wxRect *arg2 = 0 ;
30569 int arg3 = (int) wxSIZE_AUTO ;
30570 void *argp1 = 0 ;
30571 int res1 = 0 ;
30572 wxRect temp2 ;
30573 int val3 ;
30574 int ecode3 = 0 ;
30575 PyObject * obj0 = 0 ;
30576 PyObject * obj1 = 0 ;
30577 PyObject * obj2 = 0 ;
30578 char * kwnames[] = {
30579 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30580 };
30581
30582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30584 if (!SWIG_IsOK(res1)) {
30585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30586 }
30587 arg1 = reinterpret_cast< wxWindow * >(argp1);
30588 {
30589 arg2 = &temp2;
30590 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30591 }
30592 if (obj2) {
30593 ecode3 = SWIG_AsVal_int(obj2, &val3);
30594 if (!SWIG_IsOK(ecode3)) {
30595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30596 }
30597 arg3 = static_cast< int >(val3);
30598 }
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 resultobj = SWIG_Py_Void();
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30613 PyObject *resultobj = 0;
30614 wxWindow *arg1 = (wxWindow *) 0 ;
30615 int arg2 ;
30616 int arg3 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 int val2 ;
30620 int ecode2 = 0 ;
30621 int val3 ;
30622 int ecode3 = 0 ;
30623 PyObject * obj0 = 0 ;
30624 PyObject * obj1 = 0 ;
30625 PyObject * obj2 = 0 ;
30626 char * kwnames[] = {
30627 (char *) "self",(char *) "width",(char *) "height", NULL
30628 };
30629
30630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30632 if (!SWIG_IsOK(res1)) {
30633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30634 }
30635 arg1 = reinterpret_cast< wxWindow * >(argp1);
30636 ecode2 = SWIG_AsVal_int(obj1, &val2);
30637 if (!SWIG_IsOK(ecode2)) {
30638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30639 }
30640 arg2 = static_cast< int >(val2);
30641 ecode3 = SWIG_AsVal_int(obj2, &val3);
30642 if (!SWIG_IsOK(ecode3)) {
30643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30644 }
30645 arg3 = static_cast< int >(val3);
30646 {
30647 PyThreadState* __tstate = wxPyBeginAllowThreads();
30648 (arg1)->SetSize(arg2,arg3);
30649 wxPyEndAllowThreads(__tstate);
30650 if (PyErr_Occurred()) SWIG_fail;
30651 }
30652 resultobj = SWIG_Py_Void();
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj = 0;
30661 wxWindow *arg1 = (wxWindow *) 0 ;
30662 wxPoint *arg2 = 0 ;
30663 int arg3 = (int) wxSIZE_USE_EXISTING ;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 wxPoint temp2 ;
30667 int val3 ;
30668 int ecode3 = 0 ;
30669 PyObject * obj0 = 0 ;
30670 PyObject * obj1 = 0 ;
30671 PyObject * obj2 = 0 ;
30672 char * kwnames[] = {
30673 (char *) "self",(char *) "pt",(char *) "flags", NULL
30674 };
30675
30676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30678 if (!SWIG_IsOK(res1)) {
30679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30680 }
30681 arg1 = reinterpret_cast< wxWindow * >(argp1);
30682 {
30683 arg2 = &temp2;
30684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30685 }
30686 if (obj2) {
30687 ecode3 = SWIG_AsVal_int(obj2, &val3);
30688 if (!SWIG_IsOK(ecode3)) {
30689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30690 }
30691 arg3 = static_cast< int >(val3);
30692 }
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 (arg1)->Move((wxPoint const &)*arg2,arg3);
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_Py_Void();
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30707 PyObject *resultobj = 0;
30708 wxWindow *arg1 = (wxWindow *) 0 ;
30709 int arg2 ;
30710 int arg3 ;
30711 int arg4 = (int) wxSIZE_USE_EXISTING ;
30712 void *argp1 = 0 ;
30713 int res1 = 0 ;
30714 int val2 ;
30715 int ecode2 = 0 ;
30716 int val3 ;
30717 int ecode3 = 0 ;
30718 int val4 ;
30719 int ecode4 = 0 ;
30720 PyObject * obj0 = 0 ;
30721 PyObject * obj1 = 0 ;
30722 PyObject * obj2 = 0 ;
30723 PyObject * obj3 = 0 ;
30724 char * kwnames[] = {
30725 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30726 };
30727
30728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30730 if (!SWIG_IsOK(res1)) {
30731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30732 }
30733 arg1 = reinterpret_cast< wxWindow * >(argp1);
30734 ecode2 = SWIG_AsVal_int(obj1, &val2);
30735 if (!SWIG_IsOK(ecode2)) {
30736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30737 }
30738 arg2 = static_cast< int >(val2);
30739 ecode3 = SWIG_AsVal_int(obj2, &val3);
30740 if (!SWIG_IsOK(ecode3)) {
30741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30742 }
30743 arg3 = static_cast< int >(val3);
30744 if (obj3) {
30745 ecode4 = SWIG_AsVal_int(obj3, &val4);
30746 if (!SWIG_IsOK(ecode4)) {
30747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30748 }
30749 arg4 = static_cast< int >(val4);
30750 }
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 (arg1)->Move(arg2,arg3,arg4);
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 resultobj = SWIG_Py_Void();
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30765 PyObject *resultobj = 0;
30766 wxWindow *arg1 = (wxWindow *) 0 ;
30767 wxSize const &arg2_defvalue = wxDefaultSize ;
30768 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30769 void *argp1 = 0 ;
30770 int res1 = 0 ;
30771 wxSize temp2 ;
30772 PyObject * obj0 = 0 ;
30773 PyObject * obj1 = 0 ;
30774 char * kwnames[] = {
30775 (char *) "self",(char *) "size", NULL
30776 };
30777
30778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30780 if (!SWIG_IsOK(res1)) {
30781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30782 }
30783 arg1 = reinterpret_cast< wxWindow * >(argp1);
30784 if (obj1) {
30785 {
30786 arg2 = &temp2;
30787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30788 }
30789 }
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 resultobj = SWIG_Py_Void();
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30804 PyObject *resultobj = 0;
30805 wxWindow *arg1 = (wxWindow *) 0 ;
30806 void *argp1 = 0 ;
30807 int res1 = 0 ;
30808 PyObject *swig_obj[1] ;
30809
30810 if (!args) SWIG_fail;
30811 swig_obj[0] = args;
30812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30813 if (!SWIG_IsOK(res1)) {
30814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30815 }
30816 arg1 = reinterpret_cast< wxWindow * >(argp1);
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 (arg1)->Raise();
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 resultobj = SWIG_Py_Void();
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30831 PyObject *resultobj = 0;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 void *argp1 = 0 ;
30834 int res1 = 0 ;
30835 PyObject *swig_obj[1] ;
30836
30837 if (!args) SWIG_fail;
30838 swig_obj[0] = args;
30839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30840 if (!SWIG_IsOK(res1)) {
30841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30842 }
30843 arg1 = reinterpret_cast< wxWindow * >(argp1);
30844 {
30845 PyThreadState* __tstate = wxPyBeginAllowThreads();
30846 (arg1)->Lower();
30847 wxPyEndAllowThreads(__tstate);
30848 if (PyErr_Occurred()) SWIG_fail;
30849 }
30850 resultobj = SWIG_Py_Void();
30851 return resultobj;
30852 fail:
30853 return NULL;
30854 }
30855
30856
30857 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30858 PyObject *resultobj = 0;
30859 wxWindow *arg1 = (wxWindow *) 0 ;
30860 wxSize *arg2 = 0 ;
30861 void *argp1 = 0 ;
30862 int res1 = 0 ;
30863 wxSize temp2 ;
30864 PyObject * obj0 = 0 ;
30865 PyObject * obj1 = 0 ;
30866 char * kwnames[] = {
30867 (char *) "self",(char *) "size", NULL
30868 };
30869
30870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30872 if (!SWIG_IsOK(res1)) {
30873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30874 }
30875 arg1 = reinterpret_cast< wxWindow * >(argp1);
30876 {
30877 arg2 = &temp2;
30878 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30879 }
30880 {
30881 PyThreadState* __tstate = wxPyBeginAllowThreads();
30882 (arg1)->SetClientSize((wxSize const &)*arg2);
30883 wxPyEndAllowThreads(__tstate);
30884 if (PyErr_Occurred()) SWIG_fail;
30885 }
30886 resultobj = SWIG_Py_Void();
30887 return resultobj;
30888 fail:
30889 return NULL;
30890 }
30891
30892
30893 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30894 PyObject *resultobj = 0;
30895 wxWindow *arg1 = (wxWindow *) 0 ;
30896 int arg2 ;
30897 int arg3 ;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 int val2 ;
30901 int ecode2 = 0 ;
30902 int val3 ;
30903 int ecode3 = 0 ;
30904 PyObject * obj0 = 0 ;
30905 PyObject * obj1 = 0 ;
30906 PyObject * obj2 = 0 ;
30907 char * kwnames[] = {
30908 (char *) "self",(char *) "width",(char *) "height", NULL
30909 };
30910
30911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30913 if (!SWIG_IsOK(res1)) {
30914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30915 }
30916 arg1 = reinterpret_cast< wxWindow * >(argp1);
30917 ecode2 = SWIG_AsVal_int(obj1, &val2);
30918 if (!SWIG_IsOK(ecode2)) {
30919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30920 }
30921 arg2 = static_cast< int >(val2);
30922 ecode3 = SWIG_AsVal_int(obj2, &val3);
30923 if (!SWIG_IsOK(ecode3)) {
30924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30925 }
30926 arg3 = static_cast< int >(val3);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 (arg1)->SetClientSize(arg2,arg3);
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_Py_Void();
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj = 0;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 wxRect *arg2 = 0 ;
30944 void *argp1 = 0 ;
30945 int res1 = 0 ;
30946 wxRect temp2 ;
30947 PyObject * obj0 = 0 ;
30948 PyObject * obj1 = 0 ;
30949 char * kwnames[] = {
30950 (char *) "self",(char *) "rect", NULL
30951 };
30952
30953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30955 if (!SWIG_IsOK(res1)) {
30956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30957 }
30958 arg1 = reinterpret_cast< wxWindow * >(argp1);
30959 {
30960 arg2 = &temp2;
30961 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30962 }
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 (arg1)->SetClientSize((wxRect const &)*arg2);
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 resultobj = SWIG_Py_Void();
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30977 PyObject *resultobj = 0;
30978 wxWindow *arg1 = (wxWindow *) 0 ;
30979 wxPoint result;
30980 void *argp1 = 0 ;
30981 int res1 = 0 ;
30982 PyObject *swig_obj[1] ;
30983
30984 if (!args) SWIG_fail;
30985 swig_obj[0] = args;
30986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30987 if (!SWIG_IsOK(res1)) {
30988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30989 }
30990 arg1 = reinterpret_cast< wxWindow * >(argp1);
30991 {
30992 PyThreadState* __tstate = wxPyBeginAllowThreads();
30993 result = ((wxWindow const *)arg1)->GetPosition();
30994 wxPyEndAllowThreads(__tstate);
30995 if (PyErr_Occurred()) SWIG_fail;
30996 }
30997 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30998 return resultobj;
30999 fail:
31000 return NULL;
31001 }
31002
31003
31004 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31005 PyObject *resultobj = 0;
31006 wxWindow *arg1 = (wxWindow *) 0 ;
31007 int *arg2 = (int *) 0 ;
31008 int *arg3 = (int *) 0 ;
31009 void *argp1 = 0 ;
31010 int res1 = 0 ;
31011 int temp2 ;
31012 int res2 = SWIG_TMPOBJ ;
31013 int temp3 ;
31014 int res3 = SWIG_TMPOBJ ;
31015 PyObject *swig_obj[1] ;
31016
31017 arg2 = &temp2;
31018 arg3 = &temp3;
31019 if (!args) SWIG_fail;
31020 swig_obj[0] = args;
31021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31022 if (!SWIG_IsOK(res1)) {
31023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31024 }
31025 arg1 = reinterpret_cast< wxWindow * >(argp1);
31026 {
31027 PyThreadState* __tstate = wxPyBeginAllowThreads();
31028 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31029 wxPyEndAllowThreads(__tstate);
31030 if (PyErr_Occurred()) SWIG_fail;
31031 }
31032 resultobj = SWIG_Py_Void();
31033 if (SWIG_IsTmpObj(res2)) {
31034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31035 } else {
31036 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31038 }
31039 if (SWIG_IsTmpObj(res3)) {
31040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31041 } else {
31042 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31052 PyObject *resultobj = 0;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 wxPoint result;
31055 void *argp1 = 0 ;
31056 int res1 = 0 ;
31057 PyObject *swig_obj[1] ;
31058
31059 if (!args) SWIG_fail;
31060 swig_obj[0] = args;
31061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31062 if (!SWIG_IsOK(res1)) {
31063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31064 }
31065 arg1 = reinterpret_cast< wxWindow * >(argp1);
31066 {
31067 PyThreadState* __tstate = wxPyBeginAllowThreads();
31068 result = ((wxWindow const *)arg1)->GetScreenPosition();
31069 wxPyEndAllowThreads(__tstate);
31070 if (PyErr_Occurred()) SWIG_fail;
31071 }
31072 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31073 return resultobj;
31074 fail:
31075 return NULL;
31076 }
31077
31078
31079 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31080 PyObject *resultobj = 0;
31081 wxWindow *arg1 = (wxWindow *) 0 ;
31082 int *arg2 = (int *) 0 ;
31083 int *arg3 = (int *) 0 ;
31084 void *argp1 = 0 ;
31085 int res1 = 0 ;
31086 int temp2 ;
31087 int res2 = SWIG_TMPOBJ ;
31088 int temp3 ;
31089 int res3 = SWIG_TMPOBJ ;
31090 PyObject *swig_obj[1] ;
31091
31092 arg2 = &temp2;
31093 arg3 = &temp3;
31094 if (!args) SWIG_fail;
31095 swig_obj[0] = args;
31096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31099 }
31100 arg1 = reinterpret_cast< wxWindow * >(argp1);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = SWIG_Py_Void();
31108 if (SWIG_IsTmpObj(res2)) {
31109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31110 } else {
31111 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31113 }
31114 if (SWIG_IsTmpObj(res3)) {
31115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31116 } else {
31117 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31119 }
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31127 PyObject *resultobj = 0;
31128 wxWindow *arg1 = (wxWindow *) 0 ;
31129 wxRect result;
31130 void *argp1 = 0 ;
31131 int res1 = 0 ;
31132 PyObject *swig_obj[1] ;
31133
31134 if (!args) SWIG_fail;
31135 swig_obj[0] = args;
31136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31137 if (!SWIG_IsOK(res1)) {
31138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31139 }
31140 arg1 = reinterpret_cast< wxWindow * >(argp1);
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 result = ((wxWindow const *)arg1)->GetScreenRect();
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31155 PyObject *resultobj = 0;
31156 wxWindow *arg1 = (wxWindow *) 0 ;
31157 wxSize result;
31158 void *argp1 = 0 ;
31159 int res1 = 0 ;
31160 PyObject *swig_obj[1] ;
31161
31162 if (!args) SWIG_fail;
31163 swig_obj[0] = args;
31164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31165 if (!SWIG_IsOK(res1)) {
31166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31167 }
31168 arg1 = reinterpret_cast< wxWindow * >(argp1);
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 result = ((wxWindow const *)arg1)->GetSize();
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31183 PyObject *resultobj = 0;
31184 wxWindow *arg1 = (wxWindow *) 0 ;
31185 int *arg2 = (int *) 0 ;
31186 int *arg3 = (int *) 0 ;
31187 void *argp1 = 0 ;
31188 int res1 = 0 ;
31189 int temp2 ;
31190 int res2 = SWIG_TMPOBJ ;
31191 int temp3 ;
31192 int res3 = SWIG_TMPOBJ ;
31193 PyObject *swig_obj[1] ;
31194
31195 arg2 = &temp2;
31196 arg3 = &temp3;
31197 if (!args) SWIG_fail;
31198 swig_obj[0] = args;
31199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31200 if (!SWIG_IsOK(res1)) {
31201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31202 }
31203 arg1 = reinterpret_cast< wxWindow * >(argp1);
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 resultobj = SWIG_Py_Void();
31211 if (SWIG_IsTmpObj(res2)) {
31212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31213 } else {
31214 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31216 }
31217 if (SWIG_IsTmpObj(res3)) {
31218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31219 } else {
31220 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31222 }
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31230 PyObject *resultobj = 0;
31231 wxWindow *arg1 = (wxWindow *) 0 ;
31232 wxRect result;
31233 void *argp1 = 0 ;
31234 int res1 = 0 ;
31235 PyObject *swig_obj[1] ;
31236
31237 if (!args) SWIG_fail;
31238 swig_obj[0] = args;
31239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31240 if (!SWIG_IsOK(res1)) {
31241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31242 }
31243 arg1 = reinterpret_cast< wxWindow * >(argp1);
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 result = ((wxWindow const *)arg1)->GetRect();
31247 wxPyEndAllowThreads(__tstate);
31248 if (PyErr_Occurred()) SWIG_fail;
31249 }
31250 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31251 return resultobj;
31252 fail:
31253 return NULL;
31254 }
31255
31256
31257 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31258 PyObject *resultobj = 0;
31259 wxWindow *arg1 = (wxWindow *) 0 ;
31260 wxSize result;
31261 void *argp1 = 0 ;
31262 int res1 = 0 ;
31263 PyObject *swig_obj[1] ;
31264
31265 if (!args) SWIG_fail;
31266 swig_obj[0] = args;
31267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31268 if (!SWIG_IsOK(res1)) {
31269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31270 }
31271 arg1 = reinterpret_cast< wxWindow * >(argp1);
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = ((wxWindow const *)arg1)->GetClientSize();
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31286 PyObject *resultobj = 0;
31287 wxWindow *arg1 = (wxWindow *) 0 ;
31288 int *arg2 = (int *) 0 ;
31289 int *arg3 = (int *) 0 ;
31290 void *argp1 = 0 ;
31291 int res1 = 0 ;
31292 int temp2 ;
31293 int res2 = SWIG_TMPOBJ ;
31294 int temp3 ;
31295 int res3 = SWIG_TMPOBJ ;
31296 PyObject *swig_obj[1] ;
31297
31298 arg2 = &temp2;
31299 arg3 = &temp3;
31300 if (!args) SWIG_fail;
31301 swig_obj[0] = args;
31302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31303 if (!SWIG_IsOK(res1)) {
31304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31305 }
31306 arg1 = reinterpret_cast< wxWindow * >(argp1);
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_Py_Void();
31314 if (SWIG_IsTmpObj(res2)) {
31315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31316 } else {
31317 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31319 }
31320 if (SWIG_IsTmpObj(res3)) {
31321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31322 } else {
31323 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31333 PyObject *resultobj = 0;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 wxPoint result;
31336 void *argp1 = 0 ;
31337 int res1 = 0 ;
31338 PyObject *swig_obj[1] ;
31339
31340 if (!args) SWIG_fail;
31341 swig_obj[0] = args;
31342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31343 if (!SWIG_IsOK(res1)) {
31344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31345 }
31346 arg1 = reinterpret_cast< wxWindow * >(argp1);
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31361 PyObject *resultobj = 0;
31362 wxWindow *arg1 = (wxWindow *) 0 ;
31363 wxRect result;
31364 void *argp1 = 0 ;
31365 int res1 = 0 ;
31366 PyObject *swig_obj[1] ;
31367
31368 if (!args) SWIG_fail;
31369 swig_obj[0] = args;
31370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31371 if (!SWIG_IsOK(res1)) {
31372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31373 }
31374 arg1 = reinterpret_cast< wxWindow * >(argp1);
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 result = ((wxWindow const *)arg1)->GetClientRect();
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31389 PyObject *resultobj = 0;
31390 wxWindow *arg1 = (wxWindow *) 0 ;
31391 wxSize result;
31392 void *argp1 = 0 ;
31393 int res1 = 0 ;
31394 PyObject *swig_obj[1] ;
31395
31396 if (!args) SWIG_fail;
31397 swig_obj[0] = args;
31398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31399 if (!SWIG_IsOK(res1)) {
31400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31401 }
31402 arg1 = reinterpret_cast< wxWindow * >(argp1);
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 result = ((wxWindow const *)arg1)->GetBestSize();
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 PyObject *resultobj = 0;
31418 wxWindow *arg1 = (wxWindow *) 0 ;
31419 int *arg2 = (int *) 0 ;
31420 int *arg3 = (int *) 0 ;
31421 void *argp1 = 0 ;
31422 int res1 = 0 ;
31423 int temp2 ;
31424 int res2 = SWIG_TMPOBJ ;
31425 int temp3 ;
31426 int res3 = SWIG_TMPOBJ ;
31427 PyObject *swig_obj[1] ;
31428
31429 arg2 = &temp2;
31430 arg3 = &temp3;
31431 if (!args) SWIG_fail;
31432 swig_obj[0] = args;
31433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31434 if (!SWIG_IsOK(res1)) {
31435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31436 }
31437 arg1 = reinterpret_cast< wxWindow * >(argp1);
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 resultobj = SWIG_Py_Void();
31445 if (SWIG_IsTmpObj(res2)) {
31446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31447 } else {
31448 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31450 }
31451 if (SWIG_IsTmpObj(res3)) {
31452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31453 } else {
31454 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31456 }
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 PyObject *resultobj = 0;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 void *argp1 = 0 ;
31467 int res1 = 0 ;
31468 PyObject *swig_obj[1] ;
31469
31470 if (!args) SWIG_fail;
31471 swig_obj[0] = args;
31472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31473 if (!SWIG_IsOK(res1)) {
31474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31475 }
31476 arg1 = reinterpret_cast< wxWindow * >(argp1);
31477 {
31478 PyThreadState* __tstate = wxPyBeginAllowThreads();
31479 (arg1)->InvalidateBestSize();
31480 wxPyEndAllowThreads(__tstate);
31481 if (PyErr_Occurred()) SWIG_fail;
31482 }
31483 resultobj = SWIG_Py_Void();
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj = 0;
31492 wxWindow *arg1 = (wxWindow *) 0 ;
31493 wxSize *arg2 = 0 ;
31494 void *argp1 = 0 ;
31495 int res1 = 0 ;
31496 wxSize temp2 ;
31497 PyObject * obj0 = 0 ;
31498 PyObject * obj1 = 0 ;
31499 char * kwnames[] = {
31500 (char *) "self",(char *) "size", NULL
31501 };
31502
31503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31505 if (!SWIG_IsOK(res1)) {
31506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31507 }
31508 arg1 = reinterpret_cast< wxWindow * >(argp1);
31509 {
31510 arg2 = &temp2;
31511 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31512 }
31513 {
31514 PyThreadState* __tstate = wxPyBeginAllowThreads();
31515 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31516 wxPyEndAllowThreads(__tstate);
31517 if (PyErr_Occurred()) SWIG_fail;
31518 }
31519 resultobj = SWIG_Py_Void();
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31527 PyObject *resultobj = 0;
31528 wxWindow *arg1 = (wxWindow *) 0 ;
31529 wxSize result;
31530 void *argp1 = 0 ;
31531 int res1 = 0 ;
31532 PyObject *swig_obj[1] ;
31533
31534 if (!args) SWIG_fail;
31535 swig_obj[0] = args;
31536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31537 if (!SWIG_IsOK(res1)) {
31538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31539 }
31540 arg1 = reinterpret_cast< wxWindow * >(argp1);
31541 {
31542 PyThreadState* __tstate = wxPyBeginAllowThreads();
31543 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 PyObject *resultobj = 0;
31556 wxWindow *arg1 = (wxWindow *) 0 ;
31557 wxSize result;
31558 void *argp1 = 0 ;
31559 int res1 = 0 ;
31560 PyObject *swig_obj[1] ;
31561
31562 if (!args) SWIG_fail;
31563 swig_obj[0] = args;
31564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31565 if (!SWIG_IsOK(res1)) {
31566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31567 }
31568 arg1 = reinterpret_cast< wxWindow * >(argp1);
31569 {
31570 PyThreadState* __tstate = wxPyBeginAllowThreads();
31571 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31572 wxPyEndAllowThreads(__tstate);
31573 if (PyErr_Occurred()) SWIG_fail;
31574 }
31575 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31576 return resultobj;
31577 fail:
31578 return NULL;
31579 }
31580
31581
31582 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31583 PyObject *resultobj = 0;
31584 wxWindow *arg1 = (wxWindow *) 0 ;
31585 int arg2 = (int) wxBOTH ;
31586 void *argp1 = 0 ;
31587 int res1 = 0 ;
31588 int val2 ;
31589 int ecode2 = 0 ;
31590 PyObject * obj0 = 0 ;
31591 PyObject * obj1 = 0 ;
31592 char * kwnames[] = {
31593 (char *) "self",(char *) "direction", NULL
31594 };
31595
31596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) 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_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31600 }
31601 arg1 = reinterpret_cast< wxWindow * >(argp1);
31602 if (obj1) {
31603 ecode2 = SWIG_AsVal_int(obj1, &val2);
31604 if (!SWIG_IsOK(ecode2)) {
31605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31606 }
31607 arg2 = static_cast< int >(val2);
31608 }
31609 {
31610 PyThreadState* __tstate = wxPyBeginAllowThreads();
31611 (arg1)->Center(arg2);
31612 wxPyEndAllowThreads(__tstate);
31613 if (PyErr_Occurred()) SWIG_fail;
31614 }
31615 resultobj = SWIG_Py_Void();
31616 return resultobj;
31617 fail:
31618 return NULL;
31619 }
31620
31621
31622 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31623 PyObject *resultobj = 0;
31624 wxWindow *arg1 = (wxWindow *) 0 ;
31625 int arg2 = (int) wxBOTH ;
31626 void *argp1 = 0 ;
31627 int res1 = 0 ;
31628 int val2 ;
31629 int ecode2 = 0 ;
31630 PyObject * obj0 = 0 ;
31631 PyObject * obj1 = 0 ;
31632 char * kwnames[] = {
31633 (char *) "self",(char *) "dir", NULL
31634 };
31635
31636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31638 if (!SWIG_IsOK(res1)) {
31639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31640 }
31641 arg1 = reinterpret_cast< wxWindow * >(argp1);
31642 if (obj1) {
31643 ecode2 = SWIG_AsVal_int(obj1, &val2);
31644 if (!SWIG_IsOK(ecode2)) {
31645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31646 }
31647 arg2 = static_cast< int >(val2);
31648 }
31649 {
31650 PyThreadState* __tstate = wxPyBeginAllowThreads();
31651 (arg1)->CenterOnParent(arg2);
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 resultobj = SWIG_Py_Void();
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31663 PyObject *resultobj = 0;
31664 wxWindow *arg1 = (wxWindow *) 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 PyObject *swig_obj[1] ;
31668
31669 if (!args) SWIG_fail;
31670 swig_obj[0] = args;
31671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31672 if (!SWIG_IsOK(res1)) {
31673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31674 }
31675 arg1 = reinterpret_cast< wxWindow * >(argp1);
31676 {
31677 PyThreadState* __tstate = wxPyBeginAllowThreads();
31678 (arg1)->Fit();
31679 wxPyEndAllowThreads(__tstate);
31680 if (PyErr_Occurred()) SWIG_fail;
31681 }
31682 resultobj = SWIG_Py_Void();
31683 return resultobj;
31684 fail:
31685 return NULL;
31686 }
31687
31688
31689 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31690 PyObject *resultobj = 0;
31691 wxWindow *arg1 = (wxWindow *) 0 ;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject *swig_obj[1] ;
31695
31696 if (!args) SWIG_fail;
31697 swig_obj[0] = args;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31701 }
31702 arg1 = reinterpret_cast< wxWindow * >(argp1);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 (arg1)->FitInside();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_Py_Void();
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 int arg2 ;
31720 int arg3 ;
31721 int arg4 = (int) -1 ;
31722 int arg5 = (int) -1 ;
31723 int arg6 = (int) -1 ;
31724 int arg7 = (int) -1 ;
31725 void *argp1 = 0 ;
31726 int res1 = 0 ;
31727 int val2 ;
31728 int ecode2 = 0 ;
31729 int val3 ;
31730 int ecode3 = 0 ;
31731 int val4 ;
31732 int ecode4 = 0 ;
31733 int val5 ;
31734 int ecode5 = 0 ;
31735 int val6 ;
31736 int ecode6 = 0 ;
31737 int val7 ;
31738 int ecode7 = 0 ;
31739 PyObject * obj0 = 0 ;
31740 PyObject * obj1 = 0 ;
31741 PyObject * obj2 = 0 ;
31742 PyObject * obj3 = 0 ;
31743 PyObject * obj4 = 0 ;
31744 PyObject * obj5 = 0 ;
31745 PyObject * obj6 = 0 ;
31746 char * kwnames[] = {
31747 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31748 };
31749
31750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31752 if (!SWIG_IsOK(res1)) {
31753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31754 }
31755 arg1 = reinterpret_cast< wxWindow * >(argp1);
31756 ecode2 = SWIG_AsVal_int(obj1, &val2);
31757 if (!SWIG_IsOK(ecode2)) {
31758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31759 }
31760 arg2 = static_cast< int >(val2);
31761 ecode3 = SWIG_AsVal_int(obj2, &val3);
31762 if (!SWIG_IsOK(ecode3)) {
31763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31764 }
31765 arg3 = static_cast< int >(val3);
31766 if (obj3) {
31767 ecode4 = SWIG_AsVal_int(obj3, &val4);
31768 if (!SWIG_IsOK(ecode4)) {
31769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31770 }
31771 arg4 = static_cast< int >(val4);
31772 }
31773 if (obj4) {
31774 ecode5 = SWIG_AsVal_int(obj4, &val5);
31775 if (!SWIG_IsOK(ecode5)) {
31776 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31777 }
31778 arg5 = static_cast< int >(val5);
31779 }
31780 if (obj5) {
31781 ecode6 = SWIG_AsVal_int(obj5, &val6);
31782 if (!SWIG_IsOK(ecode6)) {
31783 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31784 }
31785 arg6 = static_cast< int >(val6);
31786 }
31787 if (obj6) {
31788 ecode7 = SWIG_AsVal_int(obj6, &val7);
31789 if (!SWIG_IsOK(ecode7)) {
31790 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31791 }
31792 arg7 = static_cast< int >(val7);
31793 }
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_Py_Void();
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31808 PyObject *resultobj = 0;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 wxSize *arg2 = 0 ;
31811 wxSize const &arg3_defvalue = wxDefaultSize ;
31812 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31813 wxSize const &arg4_defvalue = wxDefaultSize ;
31814 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31815 void *argp1 = 0 ;
31816 int res1 = 0 ;
31817 wxSize temp2 ;
31818 wxSize temp3 ;
31819 wxSize temp4 ;
31820 PyObject * obj0 = 0 ;
31821 PyObject * obj1 = 0 ;
31822 PyObject * obj2 = 0 ;
31823 PyObject * obj3 = 0 ;
31824 char * kwnames[] = {
31825 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31826 };
31827
31828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31830 if (!SWIG_IsOK(res1)) {
31831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31832 }
31833 arg1 = reinterpret_cast< wxWindow * >(argp1);
31834 {
31835 arg2 = &temp2;
31836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31837 }
31838 if (obj2) {
31839 {
31840 arg3 = &temp3;
31841 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31842 }
31843 }
31844 if (obj3) {
31845 {
31846 arg4 = &temp4;
31847 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31848 }
31849 }
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_Py_Void();
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = 0;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 int arg2 ;
31867 int arg3 ;
31868 int arg4 = (int) -1 ;
31869 int arg5 = (int) -1 ;
31870 void *argp1 = 0 ;
31871 int res1 = 0 ;
31872 int val2 ;
31873 int ecode2 = 0 ;
31874 int val3 ;
31875 int ecode3 = 0 ;
31876 int val4 ;
31877 int ecode4 = 0 ;
31878 int val5 ;
31879 int ecode5 = 0 ;
31880 PyObject * obj0 = 0 ;
31881 PyObject * obj1 = 0 ;
31882 PyObject * obj2 = 0 ;
31883 PyObject * obj3 = 0 ;
31884 PyObject * obj4 = 0 ;
31885 char * kwnames[] = {
31886 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31887 };
31888
31889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31893 }
31894 arg1 = reinterpret_cast< wxWindow * >(argp1);
31895 ecode2 = SWIG_AsVal_int(obj1, &val2);
31896 if (!SWIG_IsOK(ecode2)) {
31897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31898 }
31899 arg2 = static_cast< int >(val2);
31900 ecode3 = SWIG_AsVal_int(obj2, &val3);
31901 if (!SWIG_IsOK(ecode3)) {
31902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31903 }
31904 arg3 = static_cast< int >(val3);
31905 if (obj3) {
31906 ecode4 = SWIG_AsVal_int(obj3, &val4);
31907 if (!SWIG_IsOK(ecode4)) {
31908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31909 }
31910 arg4 = static_cast< int >(val4);
31911 }
31912 if (obj4) {
31913 ecode5 = SWIG_AsVal_int(obj4, &val5);
31914 if (!SWIG_IsOK(ecode5)) {
31915 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31916 }
31917 arg5 = static_cast< int >(val5);
31918 }
31919 {
31920 PyThreadState* __tstate = wxPyBeginAllowThreads();
31921 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31922 wxPyEndAllowThreads(__tstate);
31923 if (PyErr_Occurred()) SWIG_fail;
31924 }
31925 resultobj = SWIG_Py_Void();
31926 return resultobj;
31927 fail:
31928 return NULL;
31929 }
31930
31931
31932 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31933 PyObject *resultobj = 0;
31934 wxWindow *arg1 = (wxWindow *) 0 ;
31935 wxSize *arg2 = 0 ;
31936 wxSize const &arg3_defvalue = wxDefaultSize ;
31937 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31938 void *argp1 = 0 ;
31939 int res1 = 0 ;
31940 wxSize temp2 ;
31941 wxSize temp3 ;
31942 PyObject * obj0 = 0 ;
31943 PyObject * obj1 = 0 ;
31944 PyObject * obj2 = 0 ;
31945 char * kwnames[] = {
31946 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31947 };
31948
31949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31951 if (!SWIG_IsOK(res1)) {
31952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31953 }
31954 arg1 = reinterpret_cast< wxWindow * >(argp1);
31955 {
31956 arg2 = &temp2;
31957 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31958 }
31959 if (obj2) {
31960 {
31961 arg3 = &temp3;
31962 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31963 }
31964 }
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 resultobj = SWIG_Py_Void();
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31979 PyObject *resultobj = 0;
31980 wxWindow *arg1 = (wxWindow *) 0 ;
31981 wxSize result;
31982 void *argp1 = 0 ;
31983 int res1 = 0 ;
31984 PyObject *swig_obj[1] ;
31985
31986 if (!args) SWIG_fail;
31987 swig_obj[0] = args;
31988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31989 if (!SWIG_IsOK(res1)) {
31990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31991 }
31992 arg1 = reinterpret_cast< wxWindow * >(argp1);
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 result = ((wxWindow const *)arg1)->GetMaxSize();
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32007 PyObject *resultobj = 0;
32008 wxWindow *arg1 = (wxWindow *) 0 ;
32009 wxSize result;
32010 void *argp1 = 0 ;
32011 int res1 = 0 ;
32012 PyObject *swig_obj[1] ;
32013
32014 if (!args) SWIG_fail;
32015 swig_obj[0] = args;
32016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32017 if (!SWIG_IsOK(res1)) {
32018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32019 }
32020 arg1 = reinterpret_cast< wxWindow * >(argp1);
32021 {
32022 PyThreadState* __tstate = wxPyBeginAllowThreads();
32023 result = ((wxWindow const *)arg1)->GetMinSize();
32024 wxPyEndAllowThreads(__tstate);
32025 if (PyErr_Occurred()) SWIG_fail;
32026 }
32027 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32028 return resultobj;
32029 fail:
32030 return NULL;
32031 }
32032
32033
32034 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32035 PyObject *resultobj = 0;
32036 wxWindow *arg1 = (wxWindow *) 0 ;
32037 wxSize *arg2 = 0 ;
32038 void *argp1 = 0 ;
32039 int res1 = 0 ;
32040 wxSize temp2 ;
32041 PyObject * obj0 = 0 ;
32042 PyObject * obj1 = 0 ;
32043 char * kwnames[] = {
32044 (char *) "self",(char *) "minSize", NULL
32045 };
32046
32047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32049 if (!SWIG_IsOK(res1)) {
32050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32051 }
32052 arg1 = reinterpret_cast< wxWindow * >(argp1);
32053 {
32054 arg2 = &temp2;
32055 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32056 }
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 (arg1)->SetMinSize((wxSize const &)*arg2);
32060 wxPyEndAllowThreads(__tstate);
32061 if (PyErr_Occurred()) SWIG_fail;
32062 }
32063 resultobj = SWIG_Py_Void();
32064 return resultobj;
32065 fail:
32066 return NULL;
32067 }
32068
32069
32070 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32071 PyObject *resultobj = 0;
32072 wxWindow *arg1 = (wxWindow *) 0 ;
32073 wxSize *arg2 = 0 ;
32074 void *argp1 = 0 ;
32075 int res1 = 0 ;
32076 wxSize temp2 ;
32077 PyObject * obj0 = 0 ;
32078 PyObject * obj1 = 0 ;
32079 char * kwnames[] = {
32080 (char *) "self",(char *) "maxSize", NULL
32081 };
32082
32083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32085 if (!SWIG_IsOK(res1)) {
32086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32087 }
32088 arg1 = reinterpret_cast< wxWindow * >(argp1);
32089 {
32090 arg2 = &temp2;
32091 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32092 }
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 (arg1)->SetMaxSize((wxSize const &)*arg2);
32096 wxPyEndAllowThreads(__tstate);
32097 if (PyErr_Occurred()) SWIG_fail;
32098 }
32099 resultobj = SWIG_Py_Void();
32100 return resultobj;
32101 fail:
32102 return NULL;
32103 }
32104
32105
32106 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32107 PyObject *resultobj = 0;
32108 wxWindow *arg1 = (wxWindow *) 0 ;
32109 int result;
32110 void *argp1 = 0 ;
32111 int res1 = 0 ;
32112 PyObject *swig_obj[1] ;
32113
32114 if (!args) SWIG_fail;
32115 swig_obj[0] = args;
32116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32117 if (!SWIG_IsOK(res1)) {
32118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32119 }
32120 arg1 = reinterpret_cast< wxWindow * >(argp1);
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 resultobj = SWIG_From_int(static_cast< int >(result));
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32135 PyObject *resultobj = 0;
32136 wxWindow *arg1 = (wxWindow *) 0 ;
32137 int result;
32138 void *argp1 = 0 ;
32139 int res1 = 0 ;
32140 PyObject *swig_obj[1] ;
32141
32142 if (!args) SWIG_fail;
32143 swig_obj[0] = args;
32144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32145 if (!SWIG_IsOK(res1)) {
32146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32147 }
32148 arg1 = reinterpret_cast< wxWindow * >(argp1);
32149 {
32150 PyThreadState* __tstate = wxPyBeginAllowThreads();
32151 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 resultobj = SWIG_From_int(static_cast< int >(result));
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32163 PyObject *resultobj = 0;
32164 wxWindow *arg1 = (wxWindow *) 0 ;
32165 int result;
32166 void *argp1 = 0 ;
32167 int res1 = 0 ;
32168 PyObject *swig_obj[1] ;
32169
32170 if (!args) SWIG_fail;
32171 swig_obj[0] = args;
32172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32173 if (!SWIG_IsOK(res1)) {
32174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32175 }
32176 arg1 = reinterpret_cast< wxWindow * >(argp1);
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 resultobj = SWIG_From_int(static_cast< int >(result));
32184 return resultobj;
32185 fail:
32186 return NULL;
32187 }
32188
32189
32190 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32191 PyObject *resultobj = 0;
32192 wxWindow *arg1 = (wxWindow *) 0 ;
32193 int result;
32194 void *argp1 = 0 ;
32195 int res1 = 0 ;
32196 PyObject *swig_obj[1] ;
32197
32198 if (!args) SWIG_fail;
32199 swig_obj[0] = args;
32200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32201 if (!SWIG_IsOK(res1)) {
32202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32203 }
32204 arg1 = reinterpret_cast< wxWindow * >(argp1);
32205 {
32206 PyThreadState* __tstate = wxPyBeginAllowThreads();
32207 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 resultobj = SWIG_From_int(static_cast< int >(result));
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = 0;
32220 wxWindow *arg1 = (wxWindow *) 0 ;
32221 wxSize *arg2 = 0 ;
32222 void *argp1 = 0 ;
32223 int res1 = 0 ;
32224 wxSize temp2 ;
32225 PyObject * obj0 = 0 ;
32226 PyObject * obj1 = 0 ;
32227 char * kwnames[] = {
32228 (char *) "self",(char *) "size", NULL
32229 };
32230
32231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32233 if (!SWIG_IsOK(res1)) {
32234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32235 }
32236 arg1 = reinterpret_cast< wxWindow * >(argp1);
32237 {
32238 arg2 = &temp2;
32239 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32240 }
32241 {
32242 PyThreadState* __tstate = wxPyBeginAllowThreads();
32243 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32244 wxPyEndAllowThreads(__tstate);
32245 if (PyErr_Occurred()) SWIG_fail;
32246 }
32247 resultobj = SWIG_Py_Void();
32248 return resultobj;
32249 fail:
32250 return NULL;
32251 }
32252
32253
32254 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32255 PyObject *resultobj = 0;
32256 wxWindow *arg1 = (wxWindow *) 0 ;
32257 int arg2 ;
32258 int arg3 ;
32259 void *argp1 = 0 ;
32260 int res1 = 0 ;
32261 int val2 ;
32262 int ecode2 = 0 ;
32263 int val3 ;
32264 int ecode3 = 0 ;
32265 PyObject * obj0 = 0 ;
32266 PyObject * obj1 = 0 ;
32267 PyObject * obj2 = 0 ;
32268 char * kwnames[] = {
32269 (char *) "self",(char *) "w",(char *) "h", NULL
32270 };
32271
32272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32274 if (!SWIG_IsOK(res1)) {
32275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32276 }
32277 arg1 = reinterpret_cast< wxWindow * >(argp1);
32278 ecode2 = SWIG_AsVal_int(obj1, &val2);
32279 if (!SWIG_IsOK(ecode2)) {
32280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32281 }
32282 arg2 = static_cast< int >(val2);
32283 ecode3 = SWIG_AsVal_int(obj2, &val3);
32284 if (!SWIG_IsOK(ecode3)) {
32285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32286 }
32287 arg3 = static_cast< int >(val3);
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 (arg1)->SetVirtualSize(arg2,arg3);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 resultobj = SWIG_Py_Void();
32295 return resultobj;
32296 fail:
32297 return NULL;
32298 }
32299
32300
32301 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32302 PyObject *resultobj = 0;
32303 wxWindow *arg1 = (wxWindow *) 0 ;
32304 wxSize result;
32305 void *argp1 = 0 ;
32306 int res1 = 0 ;
32307 PyObject *swig_obj[1] ;
32308
32309 if (!args) SWIG_fail;
32310 swig_obj[0] = args;
32311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32312 if (!SWIG_IsOK(res1)) {
32313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32314 }
32315 arg1 = reinterpret_cast< wxWindow * >(argp1);
32316 {
32317 PyThreadState* __tstate = wxPyBeginAllowThreads();
32318 result = ((wxWindow const *)arg1)->GetVirtualSize();
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxWindow *arg1 = (wxWindow *) 0 ;
32332 int *arg2 = (int *) 0 ;
32333 int *arg3 = (int *) 0 ;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 int temp2 ;
32337 int res2 = SWIG_TMPOBJ ;
32338 int temp3 ;
32339 int res3 = SWIG_TMPOBJ ;
32340 PyObject *swig_obj[1] ;
32341
32342 arg2 = &temp2;
32343 arg3 = &temp3;
32344 if (!args) SWIG_fail;
32345 swig_obj[0] = args;
32346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32347 if (!SWIG_IsOK(res1)) {
32348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32349 }
32350 arg1 = reinterpret_cast< wxWindow * >(argp1);
32351 {
32352 PyThreadState* __tstate = wxPyBeginAllowThreads();
32353 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32354 wxPyEndAllowThreads(__tstate);
32355 if (PyErr_Occurred()) SWIG_fail;
32356 }
32357 resultobj = SWIG_Py_Void();
32358 if (SWIG_IsTmpObj(res2)) {
32359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32360 } else {
32361 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32363 }
32364 if (SWIG_IsTmpObj(res3)) {
32365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32366 } else {
32367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32369 }
32370 return resultobj;
32371 fail:
32372 return NULL;
32373 }
32374
32375
32376 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32377 PyObject *resultobj = 0;
32378 wxWindow *arg1 = (wxWindow *) 0 ;
32379 wxSize result;
32380 void *argp1 = 0 ;
32381 int res1 = 0 ;
32382 PyObject *swig_obj[1] ;
32383
32384 if (!args) SWIG_fail;
32385 swig_obj[0] = args;
32386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32387 if (!SWIG_IsOK(res1)) {
32388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32389 }
32390 arg1 = reinterpret_cast< wxWindow * >(argp1);
32391 {
32392 PyThreadState* __tstate = wxPyBeginAllowThreads();
32393 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32398 return resultobj;
32399 fail:
32400 return NULL;
32401 }
32402
32403
32404 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32405 PyObject *resultobj = 0;
32406 wxWindow *arg1 = (wxWindow *) 0 ;
32407 bool arg2 = (bool) true ;
32408 bool result;
32409 void *argp1 = 0 ;
32410 int res1 = 0 ;
32411 bool val2 ;
32412 int ecode2 = 0 ;
32413 PyObject * obj0 = 0 ;
32414 PyObject * obj1 = 0 ;
32415 char * kwnames[] = {
32416 (char *) "self",(char *) "show", NULL
32417 };
32418
32419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32421 if (!SWIG_IsOK(res1)) {
32422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32423 }
32424 arg1 = reinterpret_cast< wxWindow * >(argp1);
32425 if (obj1) {
32426 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32427 if (!SWIG_IsOK(ecode2)) {
32428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32429 }
32430 arg2 = static_cast< bool >(val2);
32431 }
32432 {
32433 PyThreadState* __tstate = wxPyBeginAllowThreads();
32434 result = (bool)(arg1)->Show(arg2);
32435 wxPyEndAllowThreads(__tstate);
32436 if (PyErr_Occurred()) SWIG_fail;
32437 }
32438 {
32439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32440 }
32441 return resultobj;
32442 fail:
32443 return NULL;
32444 }
32445
32446
32447 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32448 PyObject *resultobj = 0;
32449 wxWindow *arg1 = (wxWindow *) 0 ;
32450 bool result;
32451 void *argp1 = 0 ;
32452 int res1 = 0 ;
32453 PyObject *swig_obj[1] ;
32454
32455 if (!args) SWIG_fail;
32456 swig_obj[0] = args;
32457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32458 if (!SWIG_IsOK(res1)) {
32459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32460 }
32461 arg1 = reinterpret_cast< wxWindow * >(argp1);
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 result = (bool)(arg1)->Hide();
32465 wxPyEndAllowThreads(__tstate);
32466 if (PyErr_Occurred()) SWIG_fail;
32467 }
32468 {
32469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32470 }
32471 return resultobj;
32472 fail:
32473 return NULL;
32474 }
32475
32476
32477 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32478 PyObject *resultobj = 0;
32479 wxWindow *arg1 = (wxWindow *) 0 ;
32480 bool arg2 = (bool) true ;
32481 bool result;
32482 void *argp1 = 0 ;
32483 int res1 = 0 ;
32484 bool val2 ;
32485 int ecode2 = 0 ;
32486 PyObject * obj0 = 0 ;
32487 PyObject * obj1 = 0 ;
32488 char * kwnames[] = {
32489 (char *) "self",(char *) "enable", NULL
32490 };
32491
32492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32494 if (!SWIG_IsOK(res1)) {
32495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32496 }
32497 arg1 = reinterpret_cast< wxWindow * >(argp1);
32498 if (obj1) {
32499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32500 if (!SWIG_IsOK(ecode2)) {
32501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32502 }
32503 arg2 = static_cast< bool >(val2);
32504 }
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 result = (bool)(arg1)->Enable(arg2);
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 {
32512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32513 }
32514 return resultobj;
32515 fail:
32516 return NULL;
32517 }
32518
32519
32520 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32521 PyObject *resultobj = 0;
32522 wxWindow *arg1 = (wxWindow *) 0 ;
32523 bool result;
32524 void *argp1 = 0 ;
32525 int res1 = 0 ;
32526 PyObject *swig_obj[1] ;
32527
32528 if (!args) SWIG_fail;
32529 swig_obj[0] = args;
32530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32531 if (!SWIG_IsOK(res1)) {
32532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32533 }
32534 arg1 = reinterpret_cast< wxWindow * >(argp1);
32535 {
32536 PyThreadState* __tstate = wxPyBeginAllowThreads();
32537 result = (bool)(arg1)->Disable();
32538 wxPyEndAllowThreads(__tstate);
32539 if (PyErr_Occurred()) SWIG_fail;
32540 }
32541 {
32542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32543 }
32544 return resultobj;
32545 fail:
32546 return NULL;
32547 }
32548
32549
32550 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32551 PyObject *resultobj = 0;
32552 wxWindow *arg1 = (wxWindow *) 0 ;
32553 bool result;
32554 void *argp1 = 0 ;
32555 int res1 = 0 ;
32556 PyObject *swig_obj[1] ;
32557
32558 if (!args) SWIG_fail;
32559 swig_obj[0] = args;
32560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32561 if (!SWIG_IsOK(res1)) {
32562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32563 }
32564 arg1 = reinterpret_cast< wxWindow * >(argp1);
32565 {
32566 PyThreadState* __tstate = wxPyBeginAllowThreads();
32567 result = (bool)((wxWindow const *)arg1)->IsShown();
32568 wxPyEndAllowThreads(__tstate);
32569 if (PyErr_Occurred()) SWIG_fail;
32570 }
32571 {
32572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32573 }
32574 return resultobj;
32575 fail:
32576 return NULL;
32577 }
32578
32579
32580 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32581 PyObject *resultobj = 0;
32582 wxWindow *arg1 = (wxWindow *) 0 ;
32583 bool result;
32584 void *argp1 = 0 ;
32585 int res1 = 0 ;
32586 PyObject *swig_obj[1] ;
32587
32588 if (!args) SWIG_fail;
32589 swig_obj[0] = args;
32590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32591 if (!SWIG_IsOK(res1)) {
32592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32593 }
32594 arg1 = reinterpret_cast< wxWindow * >(argp1);
32595 {
32596 PyThreadState* __tstate = wxPyBeginAllowThreads();
32597 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 {
32602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32603 }
32604 return resultobj;
32605 fail:
32606 return NULL;
32607 }
32608
32609
32610 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32611 PyObject *resultobj = 0;
32612 wxWindow *arg1 = (wxWindow *) 0 ;
32613 long arg2 ;
32614 void *argp1 = 0 ;
32615 int res1 = 0 ;
32616 long val2 ;
32617 int ecode2 = 0 ;
32618 PyObject * obj0 = 0 ;
32619 PyObject * obj1 = 0 ;
32620 char * kwnames[] = {
32621 (char *) "self",(char *) "style", NULL
32622 };
32623
32624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32626 if (!SWIG_IsOK(res1)) {
32627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32628 }
32629 arg1 = reinterpret_cast< wxWindow * >(argp1);
32630 ecode2 = SWIG_AsVal_long(obj1, &val2);
32631 if (!SWIG_IsOK(ecode2)) {
32632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32633 }
32634 arg2 = static_cast< long >(val2);
32635 {
32636 PyThreadState* __tstate = wxPyBeginAllowThreads();
32637 (arg1)->SetWindowStyleFlag(arg2);
32638 wxPyEndAllowThreads(__tstate);
32639 if (PyErr_Occurred()) SWIG_fail;
32640 }
32641 resultobj = SWIG_Py_Void();
32642 return resultobj;
32643 fail:
32644 return NULL;
32645 }
32646
32647
32648 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32649 PyObject *resultobj = 0;
32650 wxWindow *arg1 = (wxWindow *) 0 ;
32651 long result;
32652 void *argp1 = 0 ;
32653 int res1 = 0 ;
32654 PyObject *swig_obj[1] ;
32655
32656 if (!args) SWIG_fail;
32657 swig_obj[0] = args;
32658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32659 if (!SWIG_IsOK(res1)) {
32660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32661 }
32662 arg1 = reinterpret_cast< wxWindow * >(argp1);
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_From_long(static_cast< long >(result));
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32677 PyObject *resultobj = 0;
32678 wxWindow *arg1 = (wxWindow *) 0 ;
32679 int arg2 ;
32680 bool result;
32681 void *argp1 = 0 ;
32682 int res1 = 0 ;
32683 int val2 ;
32684 int ecode2 = 0 ;
32685 PyObject * obj0 = 0 ;
32686 PyObject * obj1 = 0 ;
32687 char * kwnames[] = {
32688 (char *) "self",(char *) "flag", NULL
32689 };
32690
32691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32695 }
32696 arg1 = reinterpret_cast< wxWindow * >(argp1);
32697 ecode2 = SWIG_AsVal_int(obj1, &val2);
32698 if (!SWIG_IsOK(ecode2)) {
32699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32700 }
32701 arg2 = static_cast< int >(val2);
32702 {
32703 PyThreadState* __tstate = wxPyBeginAllowThreads();
32704 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32705 wxPyEndAllowThreads(__tstate);
32706 if (PyErr_Occurred()) SWIG_fail;
32707 }
32708 {
32709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32710 }
32711 return resultobj;
32712 fail:
32713 return NULL;
32714 }
32715
32716
32717 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32718 PyObject *resultobj = 0;
32719 wxWindow *arg1 = (wxWindow *) 0 ;
32720 bool result;
32721 void *argp1 = 0 ;
32722 int res1 = 0 ;
32723 PyObject *swig_obj[1] ;
32724
32725 if (!args) SWIG_fail;
32726 swig_obj[0] = args;
32727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32728 if (!SWIG_IsOK(res1)) {
32729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32730 }
32731 arg1 = reinterpret_cast< wxWindow * >(argp1);
32732 {
32733 PyThreadState* __tstate = wxPyBeginAllowThreads();
32734 result = (bool)((wxWindow const *)arg1)->IsRetained();
32735 wxPyEndAllowThreads(__tstate);
32736 if (PyErr_Occurred()) SWIG_fail;
32737 }
32738 {
32739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32740 }
32741 return resultobj;
32742 fail:
32743 return NULL;
32744 }
32745
32746
32747 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32748 PyObject *resultobj = 0;
32749 wxWindow *arg1 = (wxWindow *) 0 ;
32750 long arg2 ;
32751 void *argp1 = 0 ;
32752 int res1 = 0 ;
32753 long val2 ;
32754 int ecode2 = 0 ;
32755 PyObject * obj0 = 0 ;
32756 PyObject * obj1 = 0 ;
32757 char * kwnames[] = {
32758 (char *) "self",(char *) "exStyle", NULL
32759 };
32760
32761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32763 if (!SWIG_IsOK(res1)) {
32764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32765 }
32766 arg1 = reinterpret_cast< wxWindow * >(argp1);
32767 ecode2 = SWIG_AsVal_long(obj1, &val2);
32768 if (!SWIG_IsOK(ecode2)) {
32769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32770 }
32771 arg2 = static_cast< long >(val2);
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 (arg1)->SetExtraStyle(arg2);
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 resultobj = SWIG_Py_Void();
32779 return resultobj;
32780 fail:
32781 return NULL;
32782 }
32783
32784
32785 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32786 PyObject *resultobj = 0;
32787 wxWindow *arg1 = (wxWindow *) 0 ;
32788 long result;
32789 void *argp1 = 0 ;
32790 int res1 = 0 ;
32791 PyObject *swig_obj[1] ;
32792
32793 if (!args) SWIG_fail;
32794 swig_obj[0] = args;
32795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32796 if (!SWIG_IsOK(res1)) {
32797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32798 }
32799 arg1 = reinterpret_cast< wxWindow * >(argp1);
32800 {
32801 PyThreadState* __tstate = wxPyBeginAllowThreads();
32802 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32803 wxPyEndAllowThreads(__tstate);
32804 if (PyErr_Occurred()) SWIG_fail;
32805 }
32806 resultobj = SWIG_From_long(static_cast< long >(result));
32807 return resultobj;
32808 fail:
32809 return NULL;
32810 }
32811
32812
32813 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32814 PyObject *resultobj = 0;
32815 wxWindow *arg1 = (wxWindow *) 0 ;
32816 bool arg2 = (bool) true ;
32817 void *argp1 = 0 ;
32818 int res1 = 0 ;
32819 bool val2 ;
32820 int ecode2 = 0 ;
32821 PyObject * obj0 = 0 ;
32822 PyObject * obj1 = 0 ;
32823 char * kwnames[] = {
32824 (char *) "self",(char *) "modal", NULL
32825 };
32826
32827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32829 if (!SWIG_IsOK(res1)) {
32830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32831 }
32832 arg1 = reinterpret_cast< wxWindow * >(argp1);
32833 if (obj1) {
32834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32835 if (!SWIG_IsOK(ecode2)) {
32836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32837 }
32838 arg2 = static_cast< bool >(val2);
32839 }
32840 {
32841 PyThreadState* __tstate = wxPyBeginAllowThreads();
32842 (arg1)->MakeModal(arg2);
32843 wxPyEndAllowThreads(__tstate);
32844 if (PyErr_Occurred()) SWIG_fail;
32845 }
32846 resultobj = SWIG_Py_Void();
32847 return resultobj;
32848 fail:
32849 return NULL;
32850 }
32851
32852
32853 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32854 PyObject *resultobj = 0;
32855 wxWindow *arg1 = (wxWindow *) 0 ;
32856 bool arg2 ;
32857 void *argp1 = 0 ;
32858 int res1 = 0 ;
32859 bool val2 ;
32860 int ecode2 = 0 ;
32861 PyObject * obj0 = 0 ;
32862 PyObject * obj1 = 0 ;
32863 char * kwnames[] = {
32864 (char *) "self",(char *) "enableTheme", NULL
32865 };
32866
32867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32871 }
32872 arg1 = reinterpret_cast< wxWindow * >(argp1);
32873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32874 if (!SWIG_IsOK(ecode2)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32876 }
32877 arg2 = static_cast< bool >(val2);
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 (arg1)->SetThemeEnabled(arg2);
32881 wxPyEndAllowThreads(__tstate);
32882 if (PyErr_Occurred()) SWIG_fail;
32883 }
32884 resultobj = SWIG_Py_Void();
32885 return resultobj;
32886 fail:
32887 return NULL;
32888 }
32889
32890
32891 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32892 PyObject *resultobj = 0;
32893 wxWindow *arg1 = (wxWindow *) 0 ;
32894 bool result;
32895 void *argp1 = 0 ;
32896 int res1 = 0 ;
32897 PyObject *swig_obj[1] ;
32898
32899 if (!args) SWIG_fail;
32900 swig_obj[0] = args;
32901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32902 if (!SWIG_IsOK(res1)) {
32903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32904 }
32905 arg1 = reinterpret_cast< wxWindow * >(argp1);
32906 {
32907 PyThreadState* __tstate = wxPyBeginAllowThreads();
32908 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32909 wxPyEndAllowThreads(__tstate);
32910 if (PyErr_Occurred()) SWIG_fail;
32911 }
32912 {
32913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32914 }
32915 return resultobj;
32916 fail:
32917 return NULL;
32918 }
32919
32920
32921 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32922 PyObject *resultobj = 0;
32923 wxWindow *arg1 = (wxWindow *) 0 ;
32924 void *argp1 = 0 ;
32925 int res1 = 0 ;
32926 PyObject *swig_obj[1] ;
32927
32928 if (!args) SWIG_fail;
32929 swig_obj[0] = args;
32930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32931 if (!SWIG_IsOK(res1)) {
32932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32933 }
32934 arg1 = reinterpret_cast< wxWindow * >(argp1);
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 (arg1)->SetFocus();
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 resultobj = SWIG_Py_Void();
32942 return resultobj;
32943 fail:
32944 return NULL;
32945 }
32946
32947
32948 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32949 PyObject *resultobj = 0;
32950 wxWindow *arg1 = (wxWindow *) 0 ;
32951 void *argp1 = 0 ;
32952 int res1 = 0 ;
32953 PyObject *swig_obj[1] ;
32954
32955 if (!args) SWIG_fail;
32956 swig_obj[0] = args;
32957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32958 if (!SWIG_IsOK(res1)) {
32959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32960 }
32961 arg1 = reinterpret_cast< wxWindow * >(argp1);
32962 {
32963 PyThreadState* __tstate = wxPyBeginAllowThreads();
32964 (arg1)->SetFocusFromKbd();
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 resultobj = SWIG_Py_Void();
32969 return resultobj;
32970 fail:
32971 return NULL;
32972 }
32973
32974
32975 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32976 PyObject *resultobj = 0;
32977 wxWindow *result = 0 ;
32978
32979 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32980 {
32981 if (!wxPyCheckForApp()) SWIG_fail;
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (wxWindow *)wxWindow::FindFocus();
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 {
32988 resultobj = wxPyMake_wxObject(result, 0);
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject *swig_obj[1] ;
33003
33004 if (!args) SWIG_fail;
33005 swig_obj[0] = args;
33006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 {
33018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33019 }
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33027 PyObject *resultobj = 0;
33028 wxWindow *arg1 = (wxWindow *) 0 ;
33029 bool result;
33030 void *argp1 = 0 ;
33031 int res1 = 0 ;
33032 PyObject *swig_obj[1] ;
33033
33034 if (!args) SWIG_fail;
33035 swig_obj[0] = args;
33036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33037 if (!SWIG_IsOK(res1)) {
33038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33039 }
33040 arg1 = reinterpret_cast< wxWindow * >(argp1);
33041 {
33042 PyThreadState* __tstate = wxPyBeginAllowThreads();
33043 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33044 wxPyEndAllowThreads(__tstate);
33045 if (PyErr_Occurred()) SWIG_fail;
33046 }
33047 {
33048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33049 }
33050 return resultobj;
33051 fail:
33052 return NULL;
33053 }
33054
33055
33056 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33057 PyObject *resultobj = 0;
33058 wxWindow *arg1 = (wxWindow *) 0 ;
33059 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33060 bool result;
33061 void *argp1 = 0 ;
33062 int res1 = 0 ;
33063 int val2 ;
33064 int ecode2 = 0 ;
33065 PyObject * obj0 = 0 ;
33066 PyObject * obj1 = 0 ;
33067 char * kwnames[] = {
33068 (char *) "self",(char *) "flags", NULL
33069 };
33070
33071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33073 if (!SWIG_IsOK(res1)) {
33074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33075 }
33076 arg1 = reinterpret_cast< wxWindow * >(argp1);
33077 if (obj1) {
33078 ecode2 = SWIG_AsVal_int(obj1, &val2);
33079 if (!SWIG_IsOK(ecode2)) {
33080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33081 }
33082 arg2 = static_cast< int >(val2);
33083 }
33084 {
33085 PyThreadState* __tstate = wxPyBeginAllowThreads();
33086 result = (bool)(arg1)->Navigate(arg2);
33087 wxPyEndAllowThreads(__tstate);
33088 if (PyErr_Occurred()) SWIG_fail;
33089 }
33090 {
33091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33092 }
33093 return resultobj;
33094 fail:
33095 return NULL;
33096 }
33097
33098
33099 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33100 PyObject *resultobj = 0;
33101 wxWindow *arg1 = (wxWindow *) 0 ;
33102 wxWindow *arg2 = (wxWindow *) 0 ;
33103 void *argp1 = 0 ;
33104 int res1 = 0 ;
33105 void *argp2 = 0 ;
33106 int res2 = 0 ;
33107 PyObject * obj0 = 0 ;
33108 PyObject * obj1 = 0 ;
33109 char * kwnames[] = {
33110 (char *) "self",(char *) "win", NULL
33111 };
33112
33113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33115 if (!SWIG_IsOK(res1)) {
33116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33117 }
33118 arg1 = reinterpret_cast< wxWindow * >(argp1);
33119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33120 if (!SWIG_IsOK(res2)) {
33121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33122 }
33123 arg2 = reinterpret_cast< wxWindow * >(argp2);
33124 {
33125 PyThreadState* __tstate = wxPyBeginAllowThreads();
33126 (arg1)->MoveAfterInTabOrder(arg2);
33127 wxPyEndAllowThreads(__tstate);
33128 if (PyErr_Occurred()) SWIG_fail;
33129 }
33130 resultobj = SWIG_Py_Void();
33131 return resultobj;
33132 fail:
33133 return NULL;
33134 }
33135
33136
33137 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33138 PyObject *resultobj = 0;
33139 wxWindow *arg1 = (wxWindow *) 0 ;
33140 wxWindow *arg2 = (wxWindow *) 0 ;
33141 void *argp1 = 0 ;
33142 int res1 = 0 ;
33143 void *argp2 = 0 ;
33144 int res2 = 0 ;
33145 PyObject * obj0 = 0 ;
33146 PyObject * obj1 = 0 ;
33147 char * kwnames[] = {
33148 (char *) "self",(char *) "win", NULL
33149 };
33150
33151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33153 if (!SWIG_IsOK(res1)) {
33154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33155 }
33156 arg1 = reinterpret_cast< wxWindow * >(argp1);
33157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33158 if (!SWIG_IsOK(res2)) {
33159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33160 }
33161 arg2 = reinterpret_cast< wxWindow * >(argp2);
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 (arg1)->MoveBeforeInTabOrder(arg2);
33165 wxPyEndAllowThreads(__tstate);
33166 if (PyErr_Occurred()) SWIG_fail;
33167 }
33168 resultobj = SWIG_Py_Void();
33169 return resultobj;
33170 fail:
33171 return NULL;
33172 }
33173
33174
33175 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33176 PyObject *resultobj = 0;
33177 wxWindow *arg1 = (wxWindow *) 0 ;
33178 PyObject *result = 0 ;
33179 void *argp1 = 0 ;
33180 int res1 = 0 ;
33181 PyObject *swig_obj[1] ;
33182
33183 if (!args) SWIG_fail;
33184 swig_obj[0] = args;
33185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33186 if (!SWIG_IsOK(res1)) {
33187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33188 }
33189 arg1 = reinterpret_cast< wxWindow * >(argp1);
33190 {
33191 PyThreadState* __tstate = wxPyBeginAllowThreads();
33192 result = (PyObject *)wxWindow_GetChildren(arg1);
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 resultobj = result;
33197 return resultobj;
33198 fail:
33199 return NULL;
33200 }
33201
33202
33203 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33204 PyObject *resultobj = 0;
33205 wxWindow *arg1 = (wxWindow *) 0 ;
33206 wxWindow *result = 0 ;
33207 void *argp1 = 0 ;
33208 int res1 = 0 ;
33209 PyObject *swig_obj[1] ;
33210
33211 if (!args) SWIG_fail;
33212 swig_obj[0] = args;
33213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33214 if (!SWIG_IsOK(res1)) {
33215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33216 }
33217 arg1 = reinterpret_cast< wxWindow * >(argp1);
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 {
33225 resultobj = wxPyMake_wxObject(result, 0);
33226 }
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33234 PyObject *resultobj = 0;
33235 wxWindow *arg1 = (wxWindow *) 0 ;
33236 wxWindow *result = 0 ;
33237 void *argp1 = 0 ;
33238 int res1 = 0 ;
33239 PyObject *swig_obj[1] ;
33240
33241 if (!args) SWIG_fail;
33242 swig_obj[0] = args;
33243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33244 if (!SWIG_IsOK(res1)) {
33245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33246 }
33247 arg1 = reinterpret_cast< wxWindow * >(argp1);
33248 {
33249 PyThreadState* __tstate = wxPyBeginAllowThreads();
33250 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 {
33255 resultobj = wxPyMake_wxObject(result, 0);
33256 }
33257 return resultobj;
33258 fail:
33259 return NULL;
33260 }
33261
33262
33263 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33264 PyObject *resultobj = 0;
33265 wxWindow *arg1 = (wxWindow *) 0 ;
33266 bool result;
33267 void *argp1 = 0 ;
33268 int res1 = 0 ;
33269 PyObject *swig_obj[1] ;
33270
33271 if (!args) SWIG_fail;
33272 swig_obj[0] = args;
33273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33274 if (!SWIG_IsOK(res1)) {
33275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33276 }
33277 arg1 = reinterpret_cast< wxWindow * >(argp1);
33278 {
33279 PyThreadState* __tstate = wxPyBeginAllowThreads();
33280 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33281 wxPyEndAllowThreads(__tstate);
33282 if (PyErr_Occurred()) SWIG_fail;
33283 }
33284 {
33285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33286 }
33287 return resultobj;
33288 fail:
33289 return NULL;
33290 }
33291
33292
33293 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33294 PyObject *resultobj = 0;
33295 wxWindow *arg1 = (wxWindow *) 0 ;
33296 wxWindow *arg2 = (wxWindow *) 0 ;
33297 bool result;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300 void *argp2 = 0 ;
33301 int res2 = 0 ;
33302 PyObject * obj0 = 0 ;
33303 PyObject * obj1 = 0 ;
33304 char * kwnames[] = {
33305 (char *) "self",(char *) "newParent", NULL
33306 };
33307
33308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33310 if (!SWIG_IsOK(res1)) {
33311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33312 }
33313 arg1 = reinterpret_cast< wxWindow * >(argp1);
33314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33315 if (!SWIG_IsOK(res2)) {
33316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33317 }
33318 arg2 = reinterpret_cast< wxWindow * >(argp2);
33319 {
33320 PyThreadState* __tstate = wxPyBeginAllowThreads();
33321 result = (bool)(arg1)->Reparent(arg2);
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 {
33326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33327 }
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33335 PyObject *resultobj = 0;
33336 wxWindow *arg1 = (wxWindow *) 0 ;
33337 wxWindow *arg2 = (wxWindow *) 0 ;
33338 void *argp1 = 0 ;
33339 int res1 = 0 ;
33340 void *argp2 = 0 ;
33341 int res2 = 0 ;
33342 PyObject * obj0 = 0 ;
33343 PyObject * obj1 = 0 ;
33344 char * kwnames[] = {
33345 (char *) "self",(char *) "child", NULL
33346 };
33347
33348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33350 if (!SWIG_IsOK(res1)) {
33351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33352 }
33353 arg1 = reinterpret_cast< wxWindow * >(argp1);
33354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33355 if (!SWIG_IsOK(res2)) {
33356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33357 }
33358 arg2 = reinterpret_cast< wxWindow * >(argp2);
33359 {
33360 PyThreadState* __tstate = wxPyBeginAllowThreads();
33361 (arg1)->AddChild(arg2);
33362 wxPyEndAllowThreads(__tstate);
33363 if (PyErr_Occurred()) SWIG_fail;
33364 }
33365 resultobj = SWIG_Py_Void();
33366 return resultobj;
33367 fail:
33368 return NULL;
33369 }
33370
33371
33372 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33373 PyObject *resultobj = 0;
33374 wxWindow *arg1 = (wxWindow *) 0 ;
33375 wxWindow *arg2 = (wxWindow *) 0 ;
33376 void *argp1 = 0 ;
33377 int res1 = 0 ;
33378 void *argp2 = 0 ;
33379 int res2 = 0 ;
33380 PyObject * obj0 = 0 ;
33381 PyObject * obj1 = 0 ;
33382 char * kwnames[] = {
33383 (char *) "self",(char *) "child", NULL
33384 };
33385
33386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33388 if (!SWIG_IsOK(res1)) {
33389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33390 }
33391 arg1 = reinterpret_cast< wxWindow * >(argp1);
33392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33393 if (!SWIG_IsOK(res2)) {
33394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33395 }
33396 arg2 = reinterpret_cast< wxWindow * >(argp2);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 (arg1)->RemoveChild(arg2);
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 resultobj = SWIG_Py_Void();
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33411 PyObject *resultobj = 0;
33412 wxWindow *arg1 = (wxWindow *) 0 ;
33413 bool arg2 ;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 bool val2 ;
33417 int ecode2 = 0 ;
33418 PyObject * obj0 = 0 ;
33419 PyObject * obj1 = 0 ;
33420 char * kwnames[] = {
33421 (char *) "self",(char *) "on", NULL
33422 };
33423
33424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33426 if (!SWIG_IsOK(res1)) {
33427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33428 }
33429 arg1 = reinterpret_cast< wxWindow * >(argp1);
33430 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33431 if (!SWIG_IsOK(ecode2)) {
33432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33433 }
33434 arg2 = static_cast< bool >(val2);
33435 {
33436 PyThreadState* __tstate = wxPyBeginAllowThreads();
33437 wxWindow_SetDoubleBuffered(arg1,arg2);
33438 wxPyEndAllowThreads(__tstate);
33439 if (PyErr_Occurred()) SWIG_fail;
33440 }
33441 resultobj = SWIG_Py_Void();
33442 return resultobj;
33443 fail:
33444 return NULL;
33445 }
33446
33447
33448 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33449 PyObject *resultobj = 0;
33450 wxWindow *arg1 = (wxWindow *) 0 ;
33451 long arg2 ;
33452 wxWindow *result = 0 ;
33453 void *argp1 = 0 ;
33454 int res1 = 0 ;
33455 long val2 ;
33456 int ecode2 = 0 ;
33457 PyObject * obj0 = 0 ;
33458 PyObject * obj1 = 0 ;
33459 char * kwnames[] = {
33460 (char *) "self",(char *) "winid", NULL
33461 };
33462
33463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33465 if (!SWIG_IsOK(res1)) {
33466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33467 }
33468 arg1 = reinterpret_cast< wxWindow * >(argp1);
33469 ecode2 = SWIG_AsVal_long(obj1, &val2);
33470 if (!SWIG_IsOK(ecode2)) {
33471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33472 }
33473 arg2 = static_cast< long >(val2);
33474 {
33475 PyThreadState* __tstate = wxPyBeginAllowThreads();
33476 result = (wxWindow *)(arg1)->FindWindow(arg2);
33477 wxPyEndAllowThreads(__tstate);
33478 if (PyErr_Occurred()) SWIG_fail;
33479 }
33480 {
33481 resultobj = wxPyMake_wxObject(result, 0);
33482 }
33483 return resultobj;
33484 fail:
33485 return NULL;
33486 }
33487
33488
33489 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33490 PyObject *resultobj = 0;
33491 wxWindow *arg1 = (wxWindow *) 0 ;
33492 wxString *arg2 = 0 ;
33493 wxWindow *result = 0 ;
33494 void *argp1 = 0 ;
33495 int res1 = 0 ;
33496 bool temp2 = false ;
33497 PyObject * obj0 = 0 ;
33498 PyObject * obj1 = 0 ;
33499 char * kwnames[] = {
33500 (char *) "self",(char *) "name", NULL
33501 };
33502
33503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33505 if (!SWIG_IsOK(res1)) {
33506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33507 }
33508 arg1 = reinterpret_cast< wxWindow * >(argp1);
33509 {
33510 arg2 = wxString_in_helper(obj1);
33511 if (arg2 == NULL) SWIG_fail;
33512 temp2 = true;
33513 }
33514 {
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 {
33521 resultobj = wxPyMake_wxObject(result, 0);
33522 }
33523 {
33524 if (temp2)
33525 delete arg2;
33526 }
33527 return resultobj;
33528 fail:
33529 {
33530 if (temp2)
33531 delete arg2;
33532 }
33533 return NULL;
33534 }
33535
33536
33537 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33538 PyObject *resultobj = 0;
33539 wxWindow *arg1 = (wxWindow *) 0 ;
33540 wxEvtHandler *result = 0 ;
33541 void *argp1 = 0 ;
33542 int res1 = 0 ;
33543 PyObject *swig_obj[1] ;
33544
33545 if (!args) SWIG_fail;
33546 swig_obj[0] = args;
33547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33548 if (!SWIG_IsOK(res1)) {
33549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33550 }
33551 arg1 = reinterpret_cast< wxWindow * >(argp1);
33552 {
33553 PyThreadState* __tstate = wxPyBeginAllowThreads();
33554 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33555 wxPyEndAllowThreads(__tstate);
33556 if (PyErr_Occurred()) SWIG_fail;
33557 }
33558 {
33559 resultobj = wxPyMake_wxObject(result, 0);
33560 }
33561 return resultobj;
33562 fail:
33563 return NULL;
33564 }
33565
33566
33567 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33568 PyObject *resultobj = 0;
33569 wxWindow *arg1 = (wxWindow *) 0 ;
33570 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33571 void *argp1 = 0 ;
33572 int res1 = 0 ;
33573 void *argp2 = 0 ;
33574 int res2 = 0 ;
33575 PyObject * obj0 = 0 ;
33576 PyObject * obj1 = 0 ;
33577 char * kwnames[] = {
33578 (char *) "self",(char *) "handler", NULL
33579 };
33580
33581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33583 if (!SWIG_IsOK(res1)) {
33584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33585 }
33586 arg1 = reinterpret_cast< wxWindow * >(argp1);
33587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33588 if (!SWIG_IsOK(res2)) {
33589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33590 }
33591 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33592 {
33593 PyThreadState* __tstate = wxPyBeginAllowThreads();
33594 (arg1)->SetEventHandler(arg2);
33595 wxPyEndAllowThreads(__tstate);
33596 if (PyErr_Occurred()) SWIG_fail;
33597 }
33598 resultobj = SWIG_Py_Void();
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj = 0;
33607 wxWindow *arg1 = (wxWindow *) 0 ;
33608 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33609 void *argp1 = 0 ;
33610 int res1 = 0 ;
33611 void *argp2 = 0 ;
33612 int res2 = 0 ;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 char * kwnames[] = {
33616 (char *) "self",(char *) "handler", NULL
33617 };
33618
33619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33621 if (!SWIG_IsOK(res1)) {
33622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33623 }
33624 arg1 = reinterpret_cast< wxWindow * >(argp1);
33625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33626 if (!SWIG_IsOK(res2)) {
33627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33628 }
33629 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33630 {
33631 PyThreadState* __tstate = wxPyBeginAllowThreads();
33632 (arg1)->PushEventHandler(arg2);
33633 wxPyEndAllowThreads(__tstate);
33634 if (PyErr_Occurred()) SWIG_fail;
33635 }
33636 resultobj = SWIG_Py_Void();
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33644 PyObject *resultobj = 0;
33645 wxWindow *arg1 = (wxWindow *) 0 ;
33646 bool arg2 = (bool) false ;
33647 wxEvtHandler *result = 0 ;
33648 void *argp1 = 0 ;
33649 int res1 = 0 ;
33650 bool val2 ;
33651 int ecode2 = 0 ;
33652 PyObject * obj0 = 0 ;
33653 PyObject * obj1 = 0 ;
33654 char * kwnames[] = {
33655 (char *) "self",(char *) "deleteHandler", NULL
33656 };
33657
33658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33660 if (!SWIG_IsOK(res1)) {
33661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33662 }
33663 arg1 = reinterpret_cast< wxWindow * >(argp1);
33664 if (obj1) {
33665 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33666 if (!SWIG_IsOK(ecode2)) {
33667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33668 }
33669 arg2 = static_cast< bool >(val2);
33670 }
33671 {
33672 PyThreadState* __tstate = wxPyBeginAllowThreads();
33673 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 {
33678 resultobj = wxPyMake_wxObject(result, 0);
33679 }
33680 return resultobj;
33681 fail:
33682 return NULL;
33683 }
33684
33685
33686 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33687 PyObject *resultobj = 0;
33688 wxWindow *arg1 = (wxWindow *) 0 ;
33689 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33690 bool result;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 void *argp2 = 0 ;
33694 int res2 = 0 ;
33695 PyObject * obj0 = 0 ;
33696 PyObject * obj1 = 0 ;
33697 char * kwnames[] = {
33698 (char *) "self",(char *) "handler", NULL
33699 };
33700
33701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33703 if (!SWIG_IsOK(res1)) {
33704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33705 }
33706 arg1 = reinterpret_cast< wxWindow * >(argp1);
33707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33708 if (!SWIG_IsOK(res2)) {
33709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33710 }
33711 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33712 {
33713 PyThreadState* __tstate = wxPyBeginAllowThreads();
33714 result = (bool)(arg1)->RemoveEventHandler(arg2);
33715 wxPyEndAllowThreads(__tstate);
33716 if (PyErr_Occurred()) SWIG_fail;
33717 }
33718 {
33719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33720 }
33721 return resultobj;
33722 fail:
33723 return NULL;
33724 }
33725
33726
33727 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33728 PyObject *resultobj = 0;
33729 wxWindow *arg1 = (wxWindow *) 0 ;
33730 wxValidator *arg2 = 0 ;
33731 void *argp1 = 0 ;
33732 int res1 = 0 ;
33733 void *argp2 = 0 ;
33734 int res2 = 0 ;
33735 PyObject * obj0 = 0 ;
33736 PyObject * obj1 = 0 ;
33737 char * kwnames[] = {
33738 (char *) "self",(char *) "validator", NULL
33739 };
33740
33741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33743 if (!SWIG_IsOK(res1)) {
33744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33745 }
33746 arg1 = reinterpret_cast< wxWindow * >(argp1);
33747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33748 if (!SWIG_IsOK(res2)) {
33749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33750 }
33751 if (!argp2) {
33752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33753 }
33754 arg2 = reinterpret_cast< wxValidator * >(argp2);
33755 {
33756 PyThreadState* __tstate = wxPyBeginAllowThreads();
33757 (arg1)->SetValidator((wxValidator const &)*arg2);
33758 wxPyEndAllowThreads(__tstate);
33759 if (PyErr_Occurred()) SWIG_fail;
33760 }
33761 resultobj = SWIG_Py_Void();
33762 return resultobj;
33763 fail:
33764 return NULL;
33765 }
33766
33767
33768 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33769 PyObject *resultobj = 0;
33770 wxWindow *arg1 = (wxWindow *) 0 ;
33771 wxValidator *result = 0 ;
33772 void *argp1 = 0 ;
33773 int res1 = 0 ;
33774 PyObject *swig_obj[1] ;
33775
33776 if (!args) SWIG_fail;
33777 swig_obj[0] = args;
33778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33779 if (!SWIG_IsOK(res1)) {
33780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33781 }
33782 arg1 = reinterpret_cast< wxWindow * >(argp1);
33783 {
33784 PyThreadState* __tstate = wxPyBeginAllowThreads();
33785 result = (wxValidator *)(arg1)->GetValidator();
33786 wxPyEndAllowThreads(__tstate);
33787 if (PyErr_Occurred()) SWIG_fail;
33788 }
33789 {
33790 resultobj = wxPyMake_wxObject(result, (bool)0);
33791 }
33792 return resultobj;
33793 fail:
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33799 PyObject *resultobj = 0;
33800 wxWindow *arg1 = (wxWindow *) 0 ;
33801 bool result;
33802 void *argp1 = 0 ;
33803 int res1 = 0 ;
33804 PyObject *swig_obj[1] ;
33805
33806 if (!args) SWIG_fail;
33807 swig_obj[0] = args;
33808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33809 if (!SWIG_IsOK(res1)) {
33810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33811 }
33812 arg1 = reinterpret_cast< wxWindow * >(argp1);
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = (bool)(arg1)->Validate();
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 {
33820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33821 }
33822 return resultobj;
33823 fail:
33824 return NULL;
33825 }
33826
33827
33828 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33829 PyObject *resultobj = 0;
33830 wxWindow *arg1 = (wxWindow *) 0 ;
33831 bool result;
33832 void *argp1 = 0 ;
33833 int res1 = 0 ;
33834 PyObject *swig_obj[1] ;
33835
33836 if (!args) SWIG_fail;
33837 swig_obj[0] = args;
33838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33839 if (!SWIG_IsOK(res1)) {
33840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33841 }
33842 arg1 = reinterpret_cast< wxWindow * >(argp1);
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 result = (bool)(arg1)->TransferDataToWindow();
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 {
33850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33851 }
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33859 PyObject *resultobj = 0;
33860 wxWindow *arg1 = (wxWindow *) 0 ;
33861 bool result;
33862 void *argp1 = 0 ;
33863 int res1 = 0 ;
33864 PyObject *swig_obj[1] ;
33865
33866 if (!args) SWIG_fail;
33867 swig_obj[0] = args;
33868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33869 if (!SWIG_IsOK(res1)) {
33870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33871 }
33872 arg1 = reinterpret_cast< wxWindow * >(argp1);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 result = (bool)(arg1)->TransferDataFromWindow();
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 {
33880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33881 }
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33889 PyObject *resultobj = 0;
33890 wxWindow *arg1 = (wxWindow *) 0 ;
33891 void *argp1 = 0 ;
33892 int res1 = 0 ;
33893 PyObject *swig_obj[1] ;
33894
33895 if (!args) SWIG_fail;
33896 swig_obj[0] = args;
33897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33898 if (!SWIG_IsOK(res1)) {
33899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33900 }
33901 arg1 = reinterpret_cast< wxWindow * >(argp1);
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 (arg1)->InitDialog();
33905 wxPyEndAllowThreads(__tstate);
33906 if (PyErr_Occurred()) SWIG_fail;
33907 }
33908 resultobj = SWIG_Py_Void();
33909 return resultobj;
33910 fail:
33911 return NULL;
33912 }
33913
33914
33915 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33916 PyObject *resultobj = 0;
33917 wxWindow *arg1 = (wxWindow *) 0 ;
33918 wxAcceleratorTable *arg2 = 0 ;
33919 void *argp1 = 0 ;
33920 int res1 = 0 ;
33921 void *argp2 = 0 ;
33922 int res2 = 0 ;
33923 PyObject * obj0 = 0 ;
33924 PyObject * obj1 = 0 ;
33925 char * kwnames[] = {
33926 (char *) "self",(char *) "accel", NULL
33927 };
33928
33929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33936 if (!SWIG_IsOK(res2)) {
33937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33938 }
33939 if (!argp2) {
33940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33941 }
33942 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 resultobj = SWIG_Py_Void();
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33957 PyObject *resultobj = 0;
33958 wxWindow *arg1 = (wxWindow *) 0 ;
33959 wxAcceleratorTable *result = 0 ;
33960 void *argp1 = 0 ;
33961 int res1 = 0 ;
33962 PyObject *swig_obj[1] ;
33963
33964 if (!args) SWIG_fail;
33965 swig_obj[0] = args;
33966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33969 }
33970 arg1 = reinterpret_cast< wxWindow * >(argp1);
33971 {
33972 PyThreadState* __tstate = wxPyBeginAllowThreads();
33973 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33974 wxPyEndAllowThreads(__tstate);
33975 if (PyErr_Occurred()) SWIG_fail;
33976 }
33977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33978 return resultobj;
33979 fail:
33980 return NULL;
33981 }
33982
33983
33984 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33985 PyObject *resultobj = 0;
33986 wxWindow *arg1 = (wxWindow *) 0 ;
33987 int arg2 ;
33988 int arg3 ;
33989 int arg4 ;
33990 bool result;
33991 void *argp1 = 0 ;
33992 int res1 = 0 ;
33993 int val2 ;
33994 int ecode2 = 0 ;
33995 int val3 ;
33996 int ecode3 = 0 ;
33997 int val4 ;
33998 int ecode4 = 0 ;
33999 PyObject * obj0 = 0 ;
34000 PyObject * obj1 = 0 ;
34001 PyObject * obj2 = 0 ;
34002 PyObject * obj3 = 0 ;
34003 char * kwnames[] = {
34004 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34005 };
34006
34007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34009 if (!SWIG_IsOK(res1)) {
34010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34011 }
34012 arg1 = reinterpret_cast< wxWindow * >(argp1);
34013 ecode2 = SWIG_AsVal_int(obj1, &val2);
34014 if (!SWIG_IsOK(ecode2)) {
34015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34016 }
34017 arg2 = static_cast< int >(val2);
34018 ecode3 = SWIG_AsVal_int(obj2, &val3);
34019 if (!SWIG_IsOK(ecode3)) {
34020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34021 }
34022 arg3 = static_cast< int >(val3);
34023 ecode4 = SWIG_AsVal_int(obj3, &val4);
34024 if (!SWIG_IsOK(ecode4)) {
34025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34026 }
34027 arg4 = static_cast< int >(val4);
34028 {
34029 PyThreadState* __tstate = wxPyBeginAllowThreads();
34030 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34031 wxPyEndAllowThreads(__tstate);
34032 if (PyErr_Occurred()) SWIG_fail;
34033 }
34034 {
34035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34036 }
34037 return resultobj;
34038 fail:
34039 return NULL;
34040 }
34041
34042
34043 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34044 PyObject *resultobj = 0;
34045 wxWindow *arg1 = (wxWindow *) 0 ;
34046 int arg2 ;
34047 bool result;
34048 void *argp1 = 0 ;
34049 int res1 = 0 ;
34050 int val2 ;
34051 int ecode2 = 0 ;
34052 PyObject * obj0 = 0 ;
34053 PyObject * obj1 = 0 ;
34054 char * kwnames[] = {
34055 (char *) "self",(char *) "hotkeyId", NULL
34056 };
34057
34058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34060 if (!SWIG_IsOK(res1)) {
34061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34062 }
34063 arg1 = reinterpret_cast< wxWindow * >(argp1);
34064 ecode2 = SWIG_AsVal_int(obj1, &val2);
34065 if (!SWIG_IsOK(ecode2)) {
34066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34067 }
34068 arg2 = static_cast< int >(val2);
34069 {
34070 PyThreadState* __tstate = wxPyBeginAllowThreads();
34071 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34072 wxPyEndAllowThreads(__tstate);
34073 if (PyErr_Occurred()) SWIG_fail;
34074 }
34075 {
34076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34077 }
34078 return resultobj;
34079 fail:
34080 return NULL;
34081 }
34082
34083
34084 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34085 PyObject *resultobj = 0;
34086 wxWindow *arg1 = (wxWindow *) 0 ;
34087 wxPoint *arg2 = 0 ;
34088 wxPoint result;
34089 void *argp1 = 0 ;
34090 int res1 = 0 ;
34091 wxPoint temp2 ;
34092 PyObject * obj0 = 0 ;
34093 PyObject * obj1 = 0 ;
34094 char * kwnames[] = {
34095 (char *) "self",(char *) "pt", NULL
34096 };
34097
34098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34100 if (!SWIG_IsOK(res1)) {
34101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34102 }
34103 arg1 = reinterpret_cast< wxWindow * >(argp1);
34104 {
34105 arg2 = &temp2;
34106 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34107 }
34108 {
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34122 PyObject *resultobj = 0;
34123 wxWindow *arg1 = (wxWindow *) 0 ;
34124 wxSize *arg2 = 0 ;
34125 wxSize result;
34126 void *argp1 = 0 ;
34127 int res1 = 0 ;
34128 wxSize temp2 ;
34129 PyObject * obj0 = 0 ;
34130 PyObject * obj1 = 0 ;
34131 char * kwnames[] = {
34132 (char *) "self",(char *) "sz", NULL
34133 };
34134
34135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34137 if (!SWIG_IsOK(res1)) {
34138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34139 }
34140 arg1 = reinterpret_cast< wxWindow * >(argp1);
34141 {
34142 arg2 = &temp2;
34143 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34144 }
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34148 wxPyEndAllowThreads(__tstate);
34149 if (PyErr_Occurred()) SWIG_fail;
34150 }
34151 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34159 PyObject *resultobj = 0;
34160 wxWindow *arg1 = (wxWindow *) 0 ;
34161 wxPoint *arg2 = 0 ;
34162 wxPoint result;
34163 void *argp1 = 0 ;
34164 int res1 = 0 ;
34165 wxPoint temp2 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 char * kwnames[] = {
34169 (char *) "self",(char *) "pt", NULL
34170 };
34171
34172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34174 if (!SWIG_IsOK(res1)) {
34175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34176 }
34177 arg1 = reinterpret_cast< wxWindow * >(argp1);
34178 {
34179 arg2 = &temp2;
34180 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34181 }
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 wxSize *arg2 = 0 ;
34199 wxSize result;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 wxSize temp2 ;
34203 PyObject * obj0 = 0 ;
34204 PyObject * obj1 = 0 ;
34205 char * kwnames[] = {
34206 (char *) "self",(char *) "sz", NULL
34207 };
34208
34209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34211 if (!SWIG_IsOK(res1)) {
34212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34213 }
34214 arg1 = reinterpret_cast< wxWindow * >(argp1);
34215 {
34216 arg2 = &temp2;
34217 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34218 }
34219 {
34220 PyThreadState* __tstate = wxPyBeginAllowThreads();
34221 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34222 wxPyEndAllowThreads(__tstate);
34223 if (PyErr_Occurred()) SWIG_fail;
34224 }
34225 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34226 return resultobj;
34227 fail:
34228 return NULL;
34229 }
34230
34231
34232 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34233 PyObject *resultobj = 0;
34234 wxWindow *arg1 = (wxWindow *) 0 ;
34235 wxPoint *arg2 = 0 ;
34236 wxPoint result;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 wxPoint temp2 ;
34240 PyObject * obj0 = 0 ;
34241 PyObject * obj1 = 0 ;
34242 char * kwnames[] = {
34243 (char *) "self",(char *) "pt", NULL
34244 };
34245
34246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34250 }
34251 arg1 = reinterpret_cast< wxWindow * >(argp1);
34252 {
34253 arg2 = &temp2;
34254 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34255 }
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34263 return resultobj;
34264 fail:
34265 return NULL;
34266 }
34267
34268
34269 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34270 PyObject *resultobj = 0;
34271 wxWindow *arg1 = (wxWindow *) 0 ;
34272 wxSize *arg2 = 0 ;
34273 wxSize result;
34274 void *argp1 = 0 ;
34275 int res1 = 0 ;
34276 wxSize temp2 ;
34277 PyObject * obj0 = 0 ;
34278 PyObject * obj1 = 0 ;
34279 char * kwnames[] = {
34280 (char *) "self",(char *) "sz", NULL
34281 };
34282
34283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34285 if (!SWIG_IsOK(res1)) {
34286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34287 }
34288 arg1 = reinterpret_cast< wxWindow * >(argp1);
34289 {
34290 arg2 = &temp2;
34291 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34292 }
34293 {
34294 PyThreadState* __tstate = wxPyBeginAllowThreads();
34295 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34296 wxPyEndAllowThreads(__tstate);
34297 if (PyErr_Occurred()) SWIG_fail;
34298 }
34299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34300 return resultobj;
34301 fail:
34302 return NULL;
34303 }
34304
34305
34306 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34307 PyObject *resultobj = 0;
34308 wxWindow *arg1 = (wxWindow *) 0 ;
34309 int arg2 ;
34310 int arg3 ;
34311 void *argp1 = 0 ;
34312 int res1 = 0 ;
34313 int val2 ;
34314 int ecode2 = 0 ;
34315 int val3 ;
34316 int ecode3 = 0 ;
34317 PyObject * obj0 = 0 ;
34318 PyObject * obj1 = 0 ;
34319 PyObject * obj2 = 0 ;
34320 char * kwnames[] = {
34321 (char *) "self",(char *) "x",(char *) "y", NULL
34322 };
34323
34324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34326 if (!SWIG_IsOK(res1)) {
34327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34328 }
34329 arg1 = reinterpret_cast< wxWindow * >(argp1);
34330 ecode2 = SWIG_AsVal_int(obj1, &val2);
34331 if (!SWIG_IsOK(ecode2)) {
34332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34333 }
34334 arg2 = static_cast< int >(val2);
34335 ecode3 = SWIG_AsVal_int(obj2, &val3);
34336 if (!SWIG_IsOK(ecode3)) {
34337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34338 }
34339 arg3 = static_cast< int >(val3);
34340 {
34341 PyThreadState* __tstate = wxPyBeginAllowThreads();
34342 (arg1)->WarpPointer(arg2,arg3);
34343 wxPyEndAllowThreads(__tstate);
34344 if (PyErr_Occurred()) SWIG_fail;
34345 }
34346 resultobj = SWIG_Py_Void();
34347 return resultobj;
34348 fail:
34349 return NULL;
34350 }
34351
34352
34353 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34354 PyObject *resultobj = 0;
34355 wxWindow *arg1 = (wxWindow *) 0 ;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 PyObject *swig_obj[1] ;
34359
34360 if (!args) SWIG_fail;
34361 swig_obj[0] = args;
34362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34363 if (!SWIG_IsOK(res1)) {
34364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34365 }
34366 arg1 = reinterpret_cast< wxWindow * >(argp1);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 (arg1)->CaptureMouse();
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_Py_Void();
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34381 PyObject *resultobj = 0;
34382 wxWindow *arg1 = (wxWindow *) 0 ;
34383 void *argp1 = 0 ;
34384 int res1 = 0 ;
34385 PyObject *swig_obj[1] ;
34386
34387 if (!args) SWIG_fail;
34388 swig_obj[0] = args;
34389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34390 if (!SWIG_IsOK(res1)) {
34391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34392 }
34393 arg1 = reinterpret_cast< wxWindow * >(argp1);
34394 {
34395 PyThreadState* __tstate = wxPyBeginAllowThreads();
34396 (arg1)->ReleaseMouse();
34397 wxPyEndAllowThreads(__tstate);
34398 if (PyErr_Occurred()) SWIG_fail;
34399 }
34400 resultobj = SWIG_Py_Void();
34401 return resultobj;
34402 fail:
34403 return NULL;
34404 }
34405
34406
34407 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34408 PyObject *resultobj = 0;
34409 wxWindow *result = 0 ;
34410
34411 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34412 {
34413 if (!wxPyCheckForApp()) SWIG_fail;
34414 PyThreadState* __tstate = wxPyBeginAllowThreads();
34415 result = (wxWindow *)wxWindow::GetCapture();
34416 wxPyEndAllowThreads(__tstate);
34417 if (PyErr_Occurred()) SWIG_fail;
34418 }
34419 {
34420 resultobj = wxPyMake_wxObject(result, 0);
34421 }
34422 return resultobj;
34423 fail:
34424 return NULL;
34425 }
34426
34427
34428 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34429 PyObject *resultobj = 0;
34430 wxWindow *arg1 = (wxWindow *) 0 ;
34431 bool result;
34432 void *argp1 = 0 ;
34433 int res1 = 0 ;
34434 PyObject *swig_obj[1] ;
34435
34436 if (!args) SWIG_fail;
34437 swig_obj[0] = args;
34438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34439 if (!SWIG_IsOK(res1)) {
34440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34441 }
34442 arg1 = reinterpret_cast< wxWindow * >(argp1);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 result = (bool)((wxWindow const *)arg1)->HasCapture();
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 {
34450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34451 }
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34459 PyObject *resultobj = 0;
34460 wxWindow *arg1 = (wxWindow *) 0 ;
34461 bool arg2 = (bool) true ;
34462 wxRect *arg3 = (wxRect *) NULL ;
34463 void *argp1 = 0 ;
34464 int res1 = 0 ;
34465 bool val2 ;
34466 int ecode2 = 0 ;
34467 void *argp3 = 0 ;
34468 int res3 = 0 ;
34469 PyObject * obj0 = 0 ;
34470 PyObject * obj1 = 0 ;
34471 PyObject * obj2 = 0 ;
34472 char * kwnames[] = {
34473 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34474 };
34475
34476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34478 if (!SWIG_IsOK(res1)) {
34479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34480 }
34481 arg1 = reinterpret_cast< wxWindow * >(argp1);
34482 if (obj1) {
34483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34484 if (!SWIG_IsOK(ecode2)) {
34485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34486 }
34487 arg2 = static_cast< bool >(val2);
34488 }
34489 if (obj2) {
34490 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34491 if (!SWIG_IsOK(res3)) {
34492 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34493 }
34494 arg3 = reinterpret_cast< wxRect * >(argp3);
34495 }
34496 {
34497 PyThreadState* __tstate = wxPyBeginAllowThreads();
34498 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34499 wxPyEndAllowThreads(__tstate);
34500 if (PyErr_Occurred()) SWIG_fail;
34501 }
34502 resultobj = SWIG_Py_Void();
34503 return resultobj;
34504 fail:
34505 return NULL;
34506 }
34507
34508
34509 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34510 PyObject *resultobj = 0;
34511 wxWindow *arg1 = (wxWindow *) 0 ;
34512 wxRect *arg2 = 0 ;
34513 bool arg3 = (bool) true ;
34514 void *argp1 = 0 ;
34515 int res1 = 0 ;
34516 wxRect temp2 ;
34517 bool val3 ;
34518 int ecode3 = 0 ;
34519 PyObject * obj0 = 0 ;
34520 PyObject * obj1 = 0 ;
34521 PyObject * obj2 = 0 ;
34522 char * kwnames[] = {
34523 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34524 };
34525
34526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34528 if (!SWIG_IsOK(res1)) {
34529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34530 }
34531 arg1 = reinterpret_cast< wxWindow * >(argp1);
34532 {
34533 arg2 = &temp2;
34534 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34535 }
34536 if (obj2) {
34537 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34538 if (!SWIG_IsOK(ecode3)) {
34539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34540 }
34541 arg3 = static_cast< bool >(val3);
34542 }
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 resultobj = SWIG_Py_Void();
34550 return resultobj;
34551 fail:
34552 return NULL;
34553 }
34554
34555
34556 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34557 PyObject *resultobj = 0;
34558 wxWindow *arg1 = (wxWindow *) 0 ;
34559 void *argp1 = 0 ;
34560 int res1 = 0 ;
34561 PyObject *swig_obj[1] ;
34562
34563 if (!args) SWIG_fail;
34564 swig_obj[0] = args;
34565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34566 if (!SWIG_IsOK(res1)) {
34567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34568 }
34569 arg1 = reinterpret_cast< wxWindow * >(argp1);
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 (arg1)->Update();
34573 wxPyEndAllowThreads(__tstate);
34574 if (PyErr_Occurred()) SWIG_fail;
34575 }
34576 resultobj = SWIG_Py_Void();
34577 return resultobj;
34578 fail:
34579 return NULL;
34580 }
34581
34582
34583 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34584 PyObject *resultobj = 0;
34585 wxWindow *arg1 = (wxWindow *) 0 ;
34586 void *argp1 = 0 ;
34587 int res1 = 0 ;
34588 PyObject *swig_obj[1] ;
34589
34590 if (!args) SWIG_fail;
34591 swig_obj[0] = args;
34592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34593 if (!SWIG_IsOK(res1)) {
34594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34595 }
34596 arg1 = reinterpret_cast< wxWindow * >(argp1);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 (arg1)->ClearBackground();
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_Py_Void();
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 (arg1)->Freeze();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_Py_Void();
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34638 PyObject *resultobj = 0;
34639 wxWindow *arg1 = (wxWindow *) 0 ;
34640 void *argp1 = 0 ;
34641 int res1 = 0 ;
34642 PyObject *swig_obj[1] ;
34643
34644 if (!args) SWIG_fail;
34645 swig_obj[0] = args;
34646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34647 if (!SWIG_IsOK(res1)) {
34648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34649 }
34650 arg1 = reinterpret_cast< wxWindow * >(argp1);
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 (arg1)->Thaw();
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = SWIG_Py_Void();
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj = 0;
34666 wxWindow *arg1 = (wxWindow *) 0 ;
34667 wxDC *arg2 = 0 ;
34668 void *argp1 = 0 ;
34669 int res1 = 0 ;
34670 void *argp2 = 0 ;
34671 int res2 = 0 ;
34672 PyObject * obj0 = 0 ;
34673 PyObject * obj1 = 0 ;
34674 char * kwnames[] = {
34675 (char *) "self",(char *) "dc", NULL
34676 };
34677
34678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34680 if (!SWIG_IsOK(res1)) {
34681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34682 }
34683 arg1 = reinterpret_cast< wxWindow * >(argp1);
34684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34685 if (!SWIG_IsOK(res2)) {
34686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34687 }
34688 if (!argp2) {
34689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34690 }
34691 arg2 = reinterpret_cast< wxDC * >(argp2);
34692 {
34693 PyThreadState* __tstate = wxPyBeginAllowThreads();
34694 (arg1)->PrepareDC(*arg2);
34695 wxPyEndAllowThreads(__tstate);
34696 if (PyErr_Occurred()) SWIG_fail;
34697 }
34698 resultobj = SWIG_Py_Void();
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34706 PyObject *resultobj = 0;
34707 wxWindow *arg1 = (wxWindow *) 0 ;
34708 wxRegion *result = 0 ;
34709 void *argp1 = 0 ;
34710 int res1 = 0 ;
34711 PyObject *swig_obj[1] ;
34712
34713 if (!args) SWIG_fail;
34714 swig_obj[0] = args;
34715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34716 if (!SWIG_IsOK(res1)) {
34717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34718 }
34719 arg1 = reinterpret_cast< wxWindow * >(argp1);
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 {
34723 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34724 result = (wxRegion *) &_result_ref;
34725 }
34726 wxPyEndAllowThreads(__tstate);
34727 if (PyErr_Occurred()) SWIG_fail;
34728 }
34729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34737 PyObject *resultobj = 0;
34738 wxWindow *arg1 = (wxWindow *) 0 ;
34739 wxRect result;
34740 void *argp1 = 0 ;
34741 int res1 = 0 ;
34742 PyObject *swig_obj[1] ;
34743
34744 if (!args) SWIG_fail;
34745 swig_obj[0] = args;
34746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34747 if (!SWIG_IsOK(res1)) {
34748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34749 }
34750 arg1 = reinterpret_cast< wxWindow * >(argp1);
34751 {
34752 PyThreadState* __tstate = wxPyBeginAllowThreads();
34753 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj = 0;
34766 wxWindow *arg1 = (wxWindow *) 0 ;
34767 int arg2 ;
34768 int arg3 ;
34769 int arg4 = (int) 1 ;
34770 int arg5 = (int) 1 ;
34771 bool result;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 int val2 ;
34775 int ecode2 = 0 ;
34776 int val3 ;
34777 int ecode3 = 0 ;
34778 int val4 ;
34779 int ecode4 = 0 ;
34780 int val5 ;
34781 int ecode5 = 0 ;
34782 PyObject * obj0 = 0 ;
34783 PyObject * obj1 = 0 ;
34784 PyObject * obj2 = 0 ;
34785 PyObject * obj3 = 0 ;
34786 PyObject * obj4 = 0 ;
34787 char * kwnames[] = {
34788 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34789 };
34790
34791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 ecode2 = SWIG_AsVal_int(obj1, &val2);
34798 if (!SWIG_IsOK(ecode2)) {
34799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34800 }
34801 arg2 = static_cast< int >(val2);
34802 ecode3 = SWIG_AsVal_int(obj2, &val3);
34803 if (!SWIG_IsOK(ecode3)) {
34804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34805 }
34806 arg3 = static_cast< int >(val3);
34807 if (obj3) {
34808 ecode4 = SWIG_AsVal_int(obj3, &val4);
34809 if (!SWIG_IsOK(ecode4)) {
34810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34811 }
34812 arg4 = static_cast< int >(val4);
34813 }
34814 if (obj4) {
34815 ecode5 = SWIG_AsVal_int(obj4, &val5);
34816 if (!SWIG_IsOK(ecode5)) {
34817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34818 }
34819 arg5 = static_cast< int >(val5);
34820 }
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 {
34828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34829 }
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34837 PyObject *resultobj = 0;
34838 wxWindow *arg1 = (wxWindow *) 0 ;
34839 wxPoint *arg2 = 0 ;
34840 bool result;
34841 void *argp1 = 0 ;
34842 int res1 = 0 ;
34843 wxPoint temp2 ;
34844 PyObject * obj0 = 0 ;
34845 PyObject * obj1 = 0 ;
34846 char * kwnames[] = {
34847 (char *) "self",(char *) "pt", NULL
34848 };
34849
34850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34852 if (!SWIG_IsOK(res1)) {
34853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34854 }
34855 arg1 = reinterpret_cast< wxWindow * >(argp1);
34856 {
34857 arg2 = &temp2;
34858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34859 }
34860 {
34861 PyThreadState* __tstate = wxPyBeginAllowThreads();
34862 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34863 wxPyEndAllowThreads(__tstate);
34864 if (PyErr_Occurred()) SWIG_fail;
34865 }
34866 {
34867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34868 }
34869 return resultobj;
34870 fail:
34871 return NULL;
34872 }
34873
34874
34875 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34876 PyObject *resultobj = 0;
34877 wxWindow *arg1 = (wxWindow *) 0 ;
34878 wxRect *arg2 = 0 ;
34879 bool result;
34880 void *argp1 = 0 ;
34881 int res1 = 0 ;
34882 wxRect temp2 ;
34883 PyObject * obj0 = 0 ;
34884 PyObject * obj1 = 0 ;
34885 char * kwnames[] = {
34886 (char *) "self",(char *) "rect", NULL
34887 };
34888
34889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34891 if (!SWIG_IsOK(res1)) {
34892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34893 }
34894 arg1 = reinterpret_cast< wxWindow * >(argp1);
34895 {
34896 arg2 = &temp2;
34897 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34898 }
34899 {
34900 PyThreadState* __tstate = wxPyBeginAllowThreads();
34901 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34902 wxPyEndAllowThreads(__tstate);
34903 if (PyErr_Occurred()) SWIG_fail;
34904 }
34905 {
34906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34907 }
34908 return resultobj;
34909 fail:
34910 return NULL;
34911 }
34912
34913
34914 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34915 PyObject *resultobj = 0;
34916 wxWindow *arg1 = (wxWindow *) 0 ;
34917 SwigValueWrapper<wxVisualAttributes > result;
34918 void *argp1 = 0 ;
34919 int res1 = 0 ;
34920 PyObject *swig_obj[1] ;
34921
34922 if (!args) SWIG_fail;
34923 swig_obj[0] = args;
34924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34925 if (!SWIG_IsOK(res1)) {
34926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34927 }
34928 arg1 = reinterpret_cast< wxWindow * >(argp1);
34929 {
34930 PyThreadState* __tstate = wxPyBeginAllowThreads();
34931 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34932 wxPyEndAllowThreads(__tstate);
34933 if (PyErr_Occurred()) SWIG_fail;
34934 }
34935 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34936 return resultobj;
34937 fail:
34938 return NULL;
34939 }
34940
34941
34942 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34943 PyObject *resultobj = 0;
34944 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34945 SwigValueWrapper<wxVisualAttributes > result;
34946 int val1 ;
34947 int ecode1 = 0 ;
34948 PyObject * obj0 = 0 ;
34949 char * kwnames[] = {
34950 (char *) "variant", NULL
34951 };
34952
34953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34954 if (obj0) {
34955 ecode1 = SWIG_AsVal_int(obj0, &val1);
34956 if (!SWIG_IsOK(ecode1)) {
34957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34958 }
34959 arg1 = static_cast< wxWindowVariant >(val1);
34960 }
34961 {
34962 if (!wxPyCheckForApp()) SWIG_fail;
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = wxWindow::GetClassDefaultAttributes(arg1);
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34976 PyObject *resultobj = 0;
34977 wxWindow *arg1 = (wxWindow *) 0 ;
34978 wxColour *arg2 = 0 ;
34979 bool result;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 wxColour temp2 ;
34983 PyObject * obj0 = 0 ;
34984 PyObject * obj1 = 0 ;
34985 char * kwnames[] = {
34986 (char *) "self",(char *) "colour", NULL
34987 };
34988
34989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34991 if (!SWIG_IsOK(res1)) {
34992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34993 }
34994 arg1 = reinterpret_cast< wxWindow * >(argp1);
34995 {
34996 arg2 = &temp2;
34997 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34998 }
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 {
35006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35007 }
35008 return resultobj;
35009 fail:
35010 return NULL;
35011 }
35012
35013
35014 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35015 PyObject *resultobj = 0;
35016 wxWindow *arg1 = (wxWindow *) 0 ;
35017 wxColour *arg2 = 0 ;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 wxColour temp2 ;
35021 PyObject * obj0 = 0 ;
35022 PyObject * obj1 = 0 ;
35023 char * kwnames[] = {
35024 (char *) "self",(char *) "colour", NULL
35025 };
35026
35027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35029 if (!SWIG_IsOK(res1)) {
35030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35031 }
35032 arg1 = reinterpret_cast< wxWindow * >(argp1);
35033 {
35034 arg2 = &temp2;
35035 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35036 }
35037 {
35038 PyThreadState* __tstate = wxPyBeginAllowThreads();
35039 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35040 wxPyEndAllowThreads(__tstate);
35041 if (PyErr_Occurred()) SWIG_fail;
35042 }
35043 resultobj = SWIG_Py_Void();
35044 return resultobj;
35045 fail:
35046 return NULL;
35047 }
35048
35049
35050 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35051 PyObject *resultobj = 0;
35052 wxWindow *arg1 = (wxWindow *) 0 ;
35053 wxColour *arg2 = 0 ;
35054 bool result;
35055 void *argp1 = 0 ;
35056 int res1 = 0 ;
35057 wxColour temp2 ;
35058 PyObject * obj0 = 0 ;
35059 PyObject * obj1 = 0 ;
35060 char * kwnames[] = {
35061 (char *) "self",(char *) "colour", NULL
35062 };
35063
35064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35066 if (!SWIG_IsOK(res1)) {
35067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35068 }
35069 arg1 = reinterpret_cast< wxWindow * >(argp1);
35070 {
35071 arg2 = &temp2;
35072 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35073 }
35074 {
35075 PyThreadState* __tstate = wxPyBeginAllowThreads();
35076 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 {
35081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35082 }
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35090 PyObject *resultobj = 0;
35091 wxWindow *arg1 = (wxWindow *) 0 ;
35092 wxColour *arg2 = 0 ;
35093 void *argp1 = 0 ;
35094 int res1 = 0 ;
35095 wxColour temp2 ;
35096 PyObject * obj0 = 0 ;
35097 PyObject * obj1 = 0 ;
35098 char * kwnames[] = {
35099 (char *) "self",(char *) "colour", NULL
35100 };
35101
35102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35104 if (!SWIG_IsOK(res1)) {
35105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35106 }
35107 arg1 = reinterpret_cast< wxWindow * >(argp1);
35108 {
35109 arg2 = &temp2;
35110 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35111 }
35112 {
35113 PyThreadState* __tstate = wxPyBeginAllowThreads();
35114 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35115 wxPyEndAllowThreads(__tstate);
35116 if (PyErr_Occurred()) SWIG_fail;
35117 }
35118 resultobj = SWIG_Py_Void();
35119 return resultobj;
35120 fail:
35121 return NULL;
35122 }
35123
35124
35125 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35126 PyObject *resultobj = 0;
35127 wxWindow *arg1 = (wxWindow *) 0 ;
35128 wxColour result;
35129 void *argp1 = 0 ;
35130 int res1 = 0 ;
35131 PyObject *swig_obj[1] ;
35132
35133 if (!args) SWIG_fail;
35134 swig_obj[0] = args;
35135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35136 if (!SWIG_IsOK(res1)) {
35137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35138 }
35139 arg1 = reinterpret_cast< wxWindow * >(argp1);
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35154 PyObject *resultobj = 0;
35155 wxWindow *arg1 = (wxWindow *) 0 ;
35156 wxColour result;
35157 void *argp1 = 0 ;
35158 int res1 = 0 ;
35159 PyObject *swig_obj[1] ;
35160
35161 if (!args) SWIG_fail;
35162 swig_obj[0] = args;
35163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35164 if (!SWIG_IsOK(res1)) {
35165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35166 }
35167 arg1 = reinterpret_cast< wxWindow * >(argp1);
35168 {
35169 PyThreadState* __tstate = wxPyBeginAllowThreads();
35170 result = ((wxWindow const *)arg1)->GetForegroundColour();
35171 wxPyEndAllowThreads(__tstate);
35172 if (PyErr_Occurred()) SWIG_fail;
35173 }
35174 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35175 return resultobj;
35176 fail:
35177 return NULL;
35178 }
35179
35180
35181 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35182 PyObject *resultobj = 0;
35183 wxWindow *arg1 = (wxWindow *) 0 ;
35184 bool result;
35185 void *argp1 = 0 ;
35186 int res1 = 0 ;
35187 PyObject *swig_obj[1] ;
35188
35189 if (!args) SWIG_fail;
35190 swig_obj[0] = args;
35191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35192 if (!SWIG_IsOK(res1)) {
35193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35194 }
35195 arg1 = reinterpret_cast< wxWindow * >(argp1);
35196 {
35197 PyThreadState* __tstate = wxPyBeginAllowThreads();
35198 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35199 wxPyEndAllowThreads(__tstate);
35200 if (PyErr_Occurred()) SWIG_fail;
35201 }
35202 {
35203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35204 }
35205 return resultobj;
35206 fail:
35207 return NULL;
35208 }
35209
35210
35211 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35212 PyObject *resultobj = 0;
35213 wxWindow *arg1 = (wxWindow *) 0 ;
35214 bool result;
35215 void *argp1 = 0 ;
35216 int res1 = 0 ;
35217 PyObject *swig_obj[1] ;
35218
35219 if (!args) SWIG_fail;
35220 swig_obj[0] = args;
35221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35222 if (!SWIG_IsOK(res1)) {
35223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35224 }
35225 arg1 = reinterpret_cast< wxWindow * >(argp1);
35226 {
35227 PyThreadState* __tstate = wxPyBeginAllowThreads();
35228 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35229 wxPyEndAllowThreads(__tstate);
35230 if (PyErr_Occurred()) SWIG_fail;
35231 }
35232 {
35233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35234 }
35235 return resultobj;
35236 fail:
35237 return NULL;
35238 }
35239
35240
35241 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35242 PyObject *resultobj = 0;
35243 wxWindow *arg1 = (wxWindow *) 0 ;
35244 wxBackgroundStyle arg2 ;
35245 bool result;
35246 void *argp1 = 0 ;
35247 int res1 = 0 ;
35248 int val2 ;
35249 int ecode2 = 0 ;
35250 PyObject * obj0 = 0 ;
35251 PyObject * obj1 = 0 ;
35252 char * kwnames[] = {
35253 (char *) "self",(char *) "style", NULL
35254 };
35255
35256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35258 if (!SWIG_IsOK(res1)) {
35259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35260 }
35261 arg1 = reinterpret_cast< wxWindow * >(argp1);
35262 ecode2 = SWIG_AsVal_int(obj1, &val2);
35263 if (!SWIG_IsOK(ecode2)) {
35264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35265 }
35266 arg2 = static_cast< wxBackgroundStyle >(val2);
35267 {
35268 PyThreadState* __tstate = wxPyBeginAllowThreads();
35269 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35270 wxPyEndAllowThreads(__tstate);
35271 if (PyErr_Occurred()) SWIG_fail;
35272 }
35273 {
35274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35275 }
35276 return resultobj;
35277 fail:
35278 return NULL;
35279 }
35280
35281
35282 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35283 PyObject *resultobj = 0;
35284 wxWindow *arg1 = (wxWindow *) 0 ;
35285 wxBackgroundStyle result;
35286 void *argp1 = 0 ;
35287 int res1 = 0 ;
35288 PyObject *swig_obj[1] ;
35289
35290 if (!args) SWIG_fail;
35291 swig_obj[0] = args;
35292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35293 if (!SWIG_IsOK(res1)) {
35294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35295 }
35296 arg1 = reinterpret_cast< wxWindow * >(argp1);
35297 {
35298 PyThreadState* __tstate = wxPyBeginAllowThreads();
35299 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35300 wxPyEndAllowThreads(__tstate);
35301 if (PyErr_Occurred()) SWIG_fail;
35302 }
35303 resultobj = SWIG_From_int(static_cast< int >(result));
35304 return resultobj;
35305 fail:
35306 return NULL;
35307 }
35308
35309
35310 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35311 PyObject *resultobj = 0;
35312 wxWindow *arg1 = (wxWindow *) 0 ;
35313 bool result;
35314 void *argp1 = 0 ;
35315 int res1 = 0 ;
35316 PyObject *swig_obj[1] ;
35317
35318 if (!args) SWIG_fail;
35319 swig_obj[0] = args;
35320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35321 if (!SWIG_IsOK(res1)) {
35322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35323 }
35324 arg1 = reinterpret_cast< wxWindow * >(argp1);
35325 {
35326 PyThreadState* __tstate = wxPyBeginAllowThreads();
35327 result = (bool)(arg1)->HasTransparentBackground();
35328 wxPyEndAllowThreads(__tstate);
35329 if (PyErr_Occurred()) SWIG_fail;
35330 }
35331 {
35332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35333 }
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 wxCursor *arg2 = 0 ;
35344 bool result;
35345 void *argp1 = 0 ;
35346 int res1 = 0 ;
35347 void *argp2 = 0 ;
35348 int res2 = 0 ;
35349 PyObject * obj0 = 0 ;
35350 PyObject * obj1 = 0 ;
35351 char * kwnames[] = {
35352 (char *) "self",(char *) "cursor", NULL
35353 };
35354
35355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35357 if (!SWIG_IsOK(res1)) {
35358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35359 }
35360 arg1 = reinterpret_cast< wxWindow * >(argp1);
35361 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35362 if (!SWIG_IsOK(res2)) {
35363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35364 }
35365 if (!argp2) {
35366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35367 }
35368 arg2 = reinterpret_cast< wxCursor * >(argp2);
35369 {
35370 PyThreadState* __tstate = wxPyBeginAllowThreads();
35371 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35372 wxPyEndAllowThreads(__tstate);
35373 if (PyErr_Occurred()) SWIG_fail;
35374 }
35375 {
35376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35377 }
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 wxCursor result;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 PyObject *swig_obj[1] ;
35391
35392 if (!args) SWIG_fail;
35393 swig_obj[0] = args;
35394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35395 if (!SWIG_IsOK(res1)) {
35396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35397 }
35398 arg1 = reinterpret_cast< wxWindow * >(argp1);
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (arg1)->GetCursor();
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35413 PyObject *resultobj = 0;
35414 wxWindow *arg1 = (wxWindow *) 0 ;
35415 wxFont *arg2 = 0 ;
35416 bool result;
35417 void *argp1 = 0 ;
35418 int res1 = 0 ;
35419 void *argp2 = 0 ;
35420 int res2 = 0 ;
35421 PyObject * obj0 = 0 ;
35422 PyObject * obj1 = 0 ;
35423 char * kwnames[] = {
35424 (char *) "self",(char *) "font", NULL
35425 };
35426
35427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35434 if (!SWIG_IsOK(res2)) {
35435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35436 }
35437 if (!argp2) {
35438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35439 }
35440 arg2 = reinterpret_cast< wxFont * >(argp2);
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 {
35448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35449 }
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35457 PyObject *resultobj = 0;
35458 wxWindow *arg1 = (wxWindow *) 0 ;
35459 wxFont *arg2 = 0 ;
35460 void *argp1 = 0 ;
35461 int res1 = 0 ;
35462 void *argp2 = 0 ;
35463 int res2 = 0 ;
35464 PyObject * obj0 = 0 ;
35465 PyObject * obj1 = 0 ;
35466 char * kwnames[] = {
35467 (char *) "self",(char *) "font", NULL
35468 };
35469
35470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35472 if (!SWIG_IsOK(res1)) {
35473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35474 }
35475 arg1 = reinterpret_cast< wxWindow * >(argp1);
35476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35477 if (!SWIG_IsOK(res2)) {
35478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35479 }
35480 if (!argp2) {
35481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35482 }
35483 arg2 = reinterpret_cast< wxFont * >(argp2);
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 (arg1)->SetOwnFont((wxFont const &)*arg2);
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 resultobj = SWIG_Py_Void();
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35498 PyObject *resultobj = 0;
35499 wxWindow *arg1 = (wxWindow *) 0 ;
35500 wxFont result;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 PyObject *swig_obj[1] ;
35504
35505 if (!args) SWIG_fail;
35506 swig_obj[0] = args;
35507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35508 if (!SWIG_IsOK(res1)) {
35509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35510 }
35511 arg1 = reinterpret_cast< wxWindow * >(argp1);
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = (arg1)->GetFont();
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35519 return resultobj;
35520 fail:
35521 return NULL;
35522 }
35523
35524
35525 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35526 PyObject *resultobj = 0;
35527 wxWindow *arg1 = (wxWindow *) 0 ;
35528 wxCaret *arg2 = (wxCaret *) 0 ;
35529 void *argp1 = 0 ;
35530 int res1 = 0 ;
35531 int res2 = 0 ;
35532 PyObject * obj0 = 0 ;
35533 PyObject * obj1 = 0 ;
35534 char * kwnames[] = {
35535 (char *) "self",(char *) "caret", NULL
35536 };
35537
35538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35540 if (!SWIG_IsOK(res1)) {
35541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35542 }
35543 arg1 = reinterpret_cast< wxWindow * >(argp1);
35544 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35545 if (!SWIG_IsOK(res2)) {
35546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35547 }
35548 {
35549 PyThreadState* __tstate = wxPyBeginAllowThreads();
35550 (arg1)->SetCaret(arg2);
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 resultobj = SWIG_Py_Void();
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35562 PyObject *resultobj = 0;
35563 wxWindow *arg1 = (wxWindow *) 0 ;
35564 wxCaret *result = 0 ;
35565 void *argp1 = 0 ;
35566 int res1 = 0 ;
35567 PyObject *swig_obj[1] ;
35568
35569 if (!args) SWIG_fail;
35570 swig_obj[0] = args;
35571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35572 if (!SWIG_IsOK(res1)) {
35573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35574 }
35575 arg1 = reinterpret_cast< wxWindow * >(argp1);
35576 {
35577 PyThreadState* __tstate = wxPyBeginAllowThreads();
35578 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35583 return resultobj;
35584 fail:
35585 return NULL;
35586 }
35587
35588
35589 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35590 PyObject *resultobj = 0;
35591 wxWindow *arg1 = (wxWindow *) 0 ;
35592 int result;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 PyObject *swig_obj[1] ;
35596
35597 if (!args) SWIG_fail;
35598 swig_obj[0] = args;
35599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35602 }
35603 arg1 = reinterpret_cast< wxWindow * >(argp1);
35604 {
35605 PyThreadState* __tstate = wxPyBeginAllowThreads();
35606 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 resultobj = SWIG_From_int(static_cast< int >(result));
35611 return resultobj;
35612 fail:
35613 return NULL;
35614 }
35615
35616
35617 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35618 PyObject *resultobj = 0;
35619 wxWindow *arg1 = (wxWindow *) 0 ;
35620 int result;
35621 void *argp1 = 0 ;
35622 int res1 = 0 ;
35623 PyObject *swig_obj[1] ;
35624
35625 if (!args) SWIG_fail;
35626 swig_obj[0] = args;
35627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35628 if (!SWIG_IsOK(res1)) {
35629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35630 }
35631 arg1 = reinterpret_cast< wxWindow * >(argp1);
35632 {
35633 PyThreadState* __tstate = wxPyBeginAllowThreads();
35634 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35635 wxPyEndAllowThreads(__tstate);
35636 if (PyErr_Occurred()) SWIG_fail;
35637 }
35638 resultobj = SWIG_From_int(static_cast< int >(result));
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35646 PyObject *resultobj = 0;
35647 wxWindow *arg1 = (wxWindow *) 0 ;
35648 wxString *arg2 = 0 ;
35649 int *arg3 = (int *) 0 ;
35650 int *arg4 = (int *) 0 ;
35651 void *argp1 = 0 ;
35652 int res1 = 0 ;
35653 bool temp2 = false ;
35654 int temp3 ;
35655 int res3 = SWIG_TMPOBJ ;
35656 int temp4 ;
35657 int res4 = SWIG_TMPOBJ ;
35658 PyObject * obj0 = 0 ;
35659 PyObject * obj1 = 0 ;
35660 char * kwnames[] = {
35661 (char *) "self",(char *) "string", NULL
35662 };
35663
35664 arg3 = &temp3;
35665 arg4 = &temp4;
35666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35668 if (!SWIG_IsOK(res1)) {
35669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35670 }
35671 arg1 = reinterpret_cast< wxWindow * >(argp1);
35672 {
35673 arg2 = wxString_in_helper(obj1);
35674 if (arg2 == NULL) SWIG_fail;
35675 temp2 = true;
35676 }
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 resultobj = SWIG_Py_Void();
35684 if (SWIG_IsTmpObj(res3)) {
35685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35686 } else {
35687 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35689 }
35690 if (SWIG_IsTmpObj(res4)) {
35691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35692 } else {
35693 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35695 }
35696 {
35697 if (temp2)
35698 delete arg2;
35699 }
35700 return resultobj;
35701 fail:
35702 {
35703 if (temp2)
35704 delete arg2;
35705 }
35706 return NULL;
35707 }
35708
35709
35710 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35711 PyObject *resultobj = 0;
35712 wxWindow *arg1 = (wxWindow *) 0 ;
35713 wxString *arg2 = 0 ;
35714 int *arg3 = (int *) 0 ;
35715 int *arg4 = (int *) 0 ;
35716 int *arg5 = (int *) 0 ;
35717 int *arg6 = (int *) 0 ;
35718 wxFont *arg7 = (wxFont *) NULL ;
35719 void *argp1 = 0 ;
35720 int res1 = 0 ;
35721 bool temp2 = false ;
35722 int temp3 ;
35723 int res3 = SWIG_TMPOBJ ;
35724 int temp4 ;
35725 int res4 = SWIG_TMPOBJ ;
35726 int temp5 ;
35727 int res5 = SWIG_TMPOBJ ;
35728 int temp6 ;
35729 int res6 = SWIG_TMPOBJ ;
35730 void *argp7 = 0 ;
35731 int res7 = 0 ;
35732 PyObject * obj0 = 0 ;
35733 PyObject * obj1 = 0 ;
35734 PyObject * obj2 = 0 ;
35735 char * kwnames[] = {
35736 (char *) "self",(char *) "string",(char *) "font", NULL
35737 };
35738
35739 arg3 = &temp3;
35740 arg4 = &temp4;
35741 arg5 = &temp5;
35742 arg6 = &temp6;
35743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35745 if (!SWIG_IsOK(res1)) {
35746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35747 }
35748 arg1 = reinterpret_cast< wxWindow * >(argp1);
35749 {
35750 arg2 = wxString_in_helper(obj1);
35751 if (arg2 == NULL) SWIG_fail;
35752 temp2 = true;
35753 }
35754 if (obj2) {
35755 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35756 if (!SWIG_IsOK(res7)) {
35757 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35758 }
35759 arg7 = reinterpret_cast< wxFont * >(argp7);
35760 }
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 resultobj = SWIG_Py_Void();
35768 if (SWIG_IsTmpObj(res3)) {
35769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35770 } else {
35771 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35773 }
35774 if (SWIG_IsTmpObj(res4)) {
35775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35776 } else {
35777 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35779 }
35780 if (SWIG_IsTmpObj(res5)) {
35781 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35782 } else {
35783 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35784 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35785 }
35786 if (SWIG_IsTmpObj(res6)) {
35787 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35788 } else {
35789 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35791 }
35792 {
35793 if (temp2)
35794 delete arg2;
35795 }
35796 return resultobj;
35797 fail:
35798 {
35799 if (temp2)
35800 delete arg2;
35801 }
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35807 PyObject *resultobj = 0;
35808 wxWindow *arg1 = (wxWindow *) 0 ;
35809 int *arg2 = (int *) 0 ;
35810 int *arg3 = (int *) 0 ;
35811 void *argp1 = 0 ;
35812 int res1 = 0 ;
35813 int temp2 ;
35814 int res2 = 0 ;
35815 int temp3 ;
35816 int res3 = 0 ;
35817 PyObject * obj0 = 0 ;
35818 PyObject * obj1 = 0 ;
35819 PyObject * obj2 = 0 ;
35820 char * kwnames[] = {
35821 (char *) "self",(char *) "x",(char *) "y", NULL
35822 };
35823
35824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35826 if (!SWIG_IsOK(res1)) {
35827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35828 }
35829 arg1 = reinterpret_cast< wxWindow * >(argp1);
35830 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35831 int val;
35832 int ecode = SWIG_AsVal_int(obj1, &val);
35833 if (!SWIG_IsOK(ecode)) {
35834 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35835 }
35836 temp2 = static_cast< int >(val);
35837 arg2 = &temp2;
35838 res2 = SWIG_AddTmpMask(ecode);
35839 }
35840 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35841 int val;
35842 int ecode = SWIG_AsVal_int(obj2, &val);
35843 if (!SWIG_IsOK(ecode)) {
35844 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35845 }
35846 temp3 = static_cast< int >(val);
35847 arg3 = &temp3;
35848 res3 = SWIG_AddTmpMask(ecode);
35849 }
35850 {
35851 PyThreadState* __tstate = wxPyBeginAllowThreads();
35852 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35853 wxPyEndAllowThreads(__tstate);
35854 if (PyErr_Occurred()) SWIG_fail;
35855 }
35856 resultobj = SWIG_Py_Void();
35857 if (SWIG_IsTmpObj(res2)) {
35858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35859 } else {
35860 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35862 }
35863 if (SWIG_IsTmpObj(res3)) {
35864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35865 } else {
35866 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35868 }
35869 return resultobj;
35870 fail:
35871 return NULL;
35872 }
35873
35874
35875 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35876 PyObject *resultobj = 0;
35877 wxWindow *arg1 = (wxWindow *) 0 ;
35878 int *arg2 = (int *) 0 ;
35879 int *arg3 = (int *) 0 ;
35880 void *argp1 = 0 ;
35881 int res1 = 0 ;
35882 int temp2 ;
35883 int res2 = 0 ;
35884 int temp3 ;
35885 int res3 = 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 PyObject * obj2 = 0 ;
35889 char * kwnames[] = {
35890 (char *) "self",(char *) "x",(char *) "y", NULL
35891 };
35892
35893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35895 if (!SWIG_IsOK(res1)) {
35896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35897 }
35898 arg1 = reinterpret_cast< wxWindow * >(argp1);
35899 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35900 int val;
35901 int ecode = SWIG_AsVal_int(obj1, &val);
35902 if (!SWIG_IsOK(ecode)) {
35903 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35904 }
35905 temp2 = static_cast< int >(val);
35906 arg2 = &temp2;
35907 res2 = SWIG_AddTmpMask(ecode);
35908 }
35909 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35910 int val;
35911 int ecode = SWIG_AsVal_int(obj2, &val);
35912 if (!SWIG_IsOK(ecode)) {
35913 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35914 }
35915 temp3 = static_cast< int >(val);
35916 arg3 = &temp3;
35917 res3 = SWIG_AddTmpMask(ecode);
35918 }
35919 {
35920 PyThreadState* __tstate = wxPyBeginAllowThreads();
35921 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35922 wxPyEndAllowThreads(__tstate);
35923 if (PyErr_Occurred()) SWIG_fail;
35924 }
35925 resultobj = SWIG_Py_Void();
35926 if (SWIG_IsTmpObj(res2)) {
35927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35928 } else {
35929 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35931 }
35932 if (SWIG_IsTmpObj(res3)) {
35933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35934 } else {
35935 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35937 }
35938 return resultobj;
35939 fail:
35940 return NULL;
35941 }
35942
35943
35944 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35945 PyObject *resultobj = 0;
35946 wxWindow *arg1 = (wxWindow *) 0 ;
35947 wxPoint *arg2 = 0 ;
35948 wxPoint result;
35949 void *argp1 = 0 ;
35950 int res1 = 0 ;
35951 wxPoint temp2 ;
35952 PyObject * obj0 = 0 ;
35953 PyObject * obj1 = 0 ;
35954 char * kwnames[] = {
35955 (char *) "self",(char *) "pt", NULL
35956 };
35957
35958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35960 if (!SWIG_IsOK(res1)) {
35961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35962 }
35963 arg1 = reinterpret_cast< wxWindow * >(argp1);
35964 {
35965 arg2 = &temp2;
35966 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35967 }
35968 {
35969 PyThreadState* __tstate = wxPyBeginAllowThreads();
35970 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35971 wxPyEndAllowThreads(__tstate);
35972 if (PyErr_Occurred()) SWIG_fail;
35973 }
35974 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35975 return resultobj;
35976 fail:
35977 return NULL;
35978 }
35979
35980
35981 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35982 PyObject *resultobj = 0;
35983 wxWindow *arg1 = (wxWindow *) 0 ;
35984 wxPoint *arg2 = 0 ;
35985 wxPoint result;
35986 void *argp1 = 0 ;
35987 int res1 = 0 ;
35988 wxPoint temp2 ;
35989 PyObject * obj0 = 0 ;
35990 PyObject * obj1 = 0 ;
35991 char * kwnames[] = {
35992 (char *) "self",(char *) "pt", NULL
35993 };
35994
35995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35997 if (!SWIG_IsOK(res1)) {
35998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35999 }
36000 arg1 = reinterpret_cast< wxWindow * >(argp1);
36001 {
36002 arg2 = &temp2;
36003 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36004 }
36005 {
36006 PyThreadState* __tstate = wxPyBeginAllowThreads();
36007 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36008 wxPyEndAllowThreads(__tstate);
36009 if (PyErr_Occurred()) SWIG_fail;
36010 }
36011 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36012 return resultobj;
36013 fail:
36014 return NULL;
36015 }
36016
36017
36018 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36019 PyObject *resultobj = 0;
36020 wxWindow *arg1 = (wxWindow *) 0 ;
36021 int arg2 ;
36022 int arg3 ;
36023 wxHitTest result;
36024 void *argp1 = 0 ;
36025 int res1 = 0 ;
36026 int val2 ;
36027 int ecode2 = 0 ;
36028 int val3 ;
36029 int ecode3 = 0 ;
36030 PyObject * obj0 = 0 ;
36031 PyObject * obj1 = 0 ;
36032 PyObject * obj2 = 0 ;
36033 char * kwnames[] = {
36034 (char *) "self",(char *) "x",(char *) "y", NULL
36035 };
36036
36037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36039 if (!SWIG_IsOK(res1)) {
36040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36041 }
36042 arg1 = reinterpret_cast< wxWindow * >(argp1);
36043 ecode2 = SWIG_AsVal_int(obj1, &val2);
36044 if (!SWIG_IsOK(ecode2)) {
36045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36046 }
36047 arg2 = static_cast< int >(val2);
36048 ecode3 = SWIG_AsVal_int(obj2, &val3);
36049 if (!SWIG_IsOK(ecode3)) {
36050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36051 }
36052 arg3 = static_cast< int >(val3);
36053 {
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36056 wxPyEndAllowThreads(__tstate);
36057 if (PyErr_Occurred()) SWIG_fail;
36058 }
36059 resultobj = SWIG_From_int(static_cast< int >(result));
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36067 PyObject *resultobj = 0;
36068 wxWindow *arg1 = (wxWindow *) 0 ;
36069 wxPoint *arg2 = 0 ;
36070 wxHitTest result;
36071 void *argp1 = 0 ;
36072 int res1 = 0 ;
36073 wxPoint temp2 ;
36074 PyObject * obj0 = 0 ;
36075 PyObject * obj1 = 0 ;
36076 char * kwnames[] = {
36077 (char *) "self",(char *) "pt", NULL
36078 };
36079
36080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36082 if (!SWIG_IsOK(res1)) {
36083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36084 }
36085 arg1 = reinterpret_cast< wxWindow * >(argp1);
36086 {
36087 arg2 = &temp2;
36088 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36089 }
36090 {
36091 PyThreadState* __tstate = wxPyBeginAllowThreads();
36092 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 resultobj = SWIG_From_int(static_cast< int >(result));
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36104 PyObject *resultobj = 0;
36105 wxWindow *arg1 = (wxWindow *) 0 ;
36106 long arg2 ;
36107 wxBorder result;
36108 void *argp1 = 0 ;
36109 int res1 = 0 ;
36110 long val2 ;
36111 int ecode2 = 0 ;
36112
36113 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36115 if (!SWIG_IsOK(res1)) {
36116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36117 }
36118 arg1 = reinterpret_cast< wxWindow * >(argp1);
36119 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36120 if (!SWIG_IsOK(ecode2)) {
36121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36122 }
36123 arg2 = static_cast< long >(val2);
36124 {
36125 PyThreadState* __tstate = wxPyBeginAllowThreads();
36126 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36127 wxPyEndAllowThreads(__tstate);
36128 if (PyErr_Occurred()) SWIG_fail;
36129 }
36130 resultobj = SWIG_From_int(static_cast< int >(result));
36131 return resultobj;
36132 fail:
36133 return NULL;
36134 }
36135
36136
36137 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36138 PyObject *resultobj = 0;
36139 wxWindow *arg1 = (wxWindow *) 0 ;
36140 wxBorder result;
36141 void *argp1 = 0 ;
36142 int res1 = 0 ;
36143
36144 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36146 if (!SWIG_IsOK(res1)) {
36147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36148 }
36149 arg1 = reinterpret_cast< wxWindow * >(argp1);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 resultobj = SWIG_From_int(static_cast< int >(result));
36157 return resultobj;
36158 fail:
36159 return NULL;
36160 }
36161
36162
36163 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36164 int argc;
36165 PyObject *argv[3];
36166
36167 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36168 --argc;
36169 if (argc == 1) {
36170 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36171 }
36172 if (argc == 2) {
36173 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36174 }
36175
36176 fail:
36177 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36178 return NULL;
36179 }
36180
36181
36182 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36183 PyObject *resultobj = 0;
36184 wxWindow *arg1 = (wxWindow *) 0 ;
36185 long arg2 = (long) wxUPDATE_UI_NONE ;
36186 void *argp1 = 0 ;
36187 int res1 = 0 ;
36188 long val2 ;
36189 int ecode2 = 0 ;
36190 PyObject * obj0 = 0 ;
36191 PyObject * obj1 = 0 ;
36192 char * kwnames[] = {
36193 (char *) "self",(char *) "flags", NULL
36194 };
36195
36196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36198 if (!SWIG_IsOK(res1)) {
36199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36200 }
36201 arg1 = reinterpret_cast< wxWindow * >(argp1);
36202 if (obj1) {
36203 ecode2 = SWIG_AsVal_long(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36206 }
36207 arg2 = static_cast< long >(val2);
36208 }
36209 {
36210 PyThreadState* __tstate = wxPyBeginAllowThreads();
36211 (arg1)->UpdateWindowUI(arg2);
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 resultobj = SWIG_Py_Void();
36216 return resultobj;
36217 fail:
36218 return NULL;
36219 }
36220
36221
36222 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36223 PyObject *resultobj = 0;
36224 wxWindow *arg1 = (wxWindow *) 0 ;
36225 wxMenu *arg2 = (wxMenu *) 0 ;
36226 int arg3 = (int) -1 ;
36227 int arg4 = (int) -1 ;
36228 bool result;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 void *argp2 = 0 ;
36232 int res2 = 0 ;
36233 int val3 ;
36234 int ecode3 = 0 ;
36235 int val4 ;
36236 int ecode4 = 0 ;
36237 PyObject * obj0 = 0 ;
36238 PyObject * obj1 = 0 ;
36239 PyObject * obj2 = 0 ;
36240 PyObject * obj3 = 0 ;
36241 char * kwnames[] = {
36242 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36243 };
36244
36245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36249 }
36250 arg1 = reinterpret_cast< wxWindow * >(argp1);
36251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36252 if (!SWIG_IsOK(res2)) {
36253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36254 }
36255 arg2 = reinterpret_cast< wxMenu * >(argp2);
36256 if (obj2) {
36257 ecode3 = SWIG_AsVal_int(obj2, &val3);
36258 if (!SWIG_IsOK(ecode3)) {
36259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36260 }
36261 arg3 = static_cast< int >(val3);
36262 }
36263 if (obj3) {
36264 ecode4 = SWIG_AsVal_int(obj3, &val4);
36265 if (!SWIG_IsOK(ecode4)) {
36266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36267 }
36268 arg4 = static_cast< int >(val4);
36269 }
36270 {
36271 PyThreadState* __tstate = wxPyBeginAllowThreads();
36272 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36273 wxPyEndAllowThreads(__tstate);
36274 if (PyErr_Occurred()) SWIG_fail;
36275 }
36276 {
36277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36278 }
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj = 0;
36287 wxWindow *arg1 = (wxWindow *) 0 ;
36288 wxMenu *arg2 = (wxMenu *) 0 ;
36289 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36290 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36291 bool result;
36292 void *argp1 = 0 ;
36293 int res1 = 0 ;
36294 void *argp2 = 0 ;
36295 int res2 = 0 ;
36296 wxPoint temp3 ;
36297 PyObject * obj0 = 0 ;
36298 PyObject * obj1 = 0 ;
36299 PyObject * obj2 = 0 ;
36300 char * kwnames[] = {
36301 (char *) "self",(char *) "menu",(char *) "pos", NULL
36302 };
36303
36304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36306 if (!SWIG_IsOK(res1)) {
36307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36308 }
36309 arg1 = reinterpret_cast< wxWindow * >(argp1);
36310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36311 if (!SWIG_IsOK(res2)) {
36312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36313 }
36314 arg2 = reinterpret_cast< wxMenu * >(argp2);
36315 if (obj2) {
36316 {
36317 arg3 = &temp3;
36318 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36319 }
36320 }
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 {
36328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36329 }
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36337 PyObject *resultobj = 0;
36338 wxWindow *arg1 = (wxWindow *) 0 ;
36339 bool result;
36340 void *argp1 = 0 ;
36341 int res1 = 0 ;
36342 PyObject *swig_obj[1] ;
36343
36344 if (!args) SWIG_fail;
36345 swig_obj[0] = args;
36346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36347 if (!SWIG_IsOK(res1)) {
36348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36349 }
36350 arg1 = reinterpret_cast< wxWindow * >(argp1);
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 {
36358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36359 }
36360 return resultobj;
36361 fail:
36362 return NULL;
36363 }
36364
36365
36366 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36367 PyObject *resultobj = 0;
36368 wxWindow *arg1 = (wxWindow *) 0 ;
36369 long result;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 PyObject *swig_obj[1] ;
36373
36374 if (!args) SWIG_fail;
36375 swig_obj[0] = args;
36376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36377 if (!SWIG_IsOK(res1)) {
36378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36379 }
36380 arg1 = reinterpret_cast< wxWindow * >(argp1);
36381 {
36382 PyThreadState* __tstate = wxPyBeginAllowThreads();
36383 result = (long)wxWindow_GetHandle(arg1);
36384 wxPyEndAllowThreads(__tstate);
36385 if (PyErr_Occurred()) SWIG_fail;
36386 }
36387 resultobj = SWIG_From_long(static_cast< long >(result));
36388 return resultobj;
36389 fail:
36390 return NULL;
36391 }
36392
36393
36394 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36395 PyObject *resultobj = 0;
36396 wxWindow *arg1 = (wxWindow *) 0 ;
36397 long arg2 ;
36398 void *argp1 = 0 ;
36399 int res1 = 0 ;
36400 long val2 ;
36401 int ecode2 = 0 ;
36402 PyObject * obj0 = 0 ;
36403 PyObject * obj1 = 0 ;
36404 char * kwnames[] = {
36405 (char *) "self",(char *) "handle", NULL
36406 };
36407
36408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36410 if (!SWIG_IsOK(res1)) {
36411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36412 }
36413 arg1 = reinterpret_cast< wxWindow * >(argp1);
36414 ecode2 = SWIG_AsVal_long(obj1, &val2);
36415 if (!SWIG_IsOK(ecode2)) {
36416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36417 }
36418 arg2 = static_cast< long >(val2);
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 wxWindow_AssociateHandle(arg1,arg2);
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_Py_Void();
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 void *argp1 = 0 ;
36436 int res1 = 0 ;
36437 PyObject *swig_obj[1] ;
36438
36439 if (!args) SWIG_fail;
36440 swig_obj[0] = args;
36441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36442 if (!SWIG_IsOK(res1)) {
36443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36444 }
36445 arg1 = reinterpret_cast< wxWindow * >(argp1);
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 (arg1)->DissociateHandle();
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = SWIG_Py_Void();
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 wxPaintEvent *arg2 = 0 ;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 void *argp2 = 0 ;
36466 int res2 = 0 ;
36467 PyObject * obj0 = 0 ;
36468 PyObject * obj1 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "self",(char *) "event", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36480 if (!SWIG_IsOK(res2)) {
36481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36482 }
36483 if (!argp2) {
36484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36485 }
36486 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 (arg1)->OnPaint(*arg2);
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 resultobj = SWIG_Py_Void();
36494 return resultobj;
36495 fail:
36496 return NULL;
36497 }
36498
36499
36500 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36501 PyObject *resultobj = 0;
36502 wxWindow *arg1 = (wxWindow *) 0 ;
36503 int arg2 ;
36504 bool result;
36505 void *argp1 = 0 ;
36506 int res1 = 0 ;
36507 int val2 ;
36508 int ecode2 = 0 ;
36509 PyObject * obj0 = 0 ;
36510 PyObject * obj1 = 0 ;
36511 char * kwnames[] = {
36512 (char *) "self",(char *) "orient", NULL
36513 };
36514
36515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36517 if (!SWIG_IsOK(res1)) {
36518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36519 }
36520 arg1 = reinterpret_cast< wxWindow * >(argp1);
36521 ecode2 = SWIG_AsVal_int(obj1, &val2);
36522 if (!SWIG_IsOK(ecode2)) {
36523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36524 }
36525 arg2 = static_cast< int >(val2);
36526 {
36527 PyThreadState* __tstate = wxPyBeginAllowThreads();
36528 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36529 wxPyEndAllowThreads(__tstate);
36530 if (PyErr_Occurred()) SWIG_fail;
36531 }
36532 {
36533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36534 }
36535 return resultobj;
36536 fail:
36537 return NULL;
36538 }
36539
36540
36541 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj = 0;
36543 wxWindow *arg1 = (wxWindow *) 0 ;
36544 int arg2 ;
36545 int arg3 ;
36546 int arg4 ;
36547 int arg5 ;
36548 bool arg6 = (bool) true ;
36549 void *argp1 = 0 ;
36550 int res1 = 0 ;
36551 int val2 ;
36552 int ecode2 = 0 ;
36553 int val3 ;
36554 int ecode3 = 0 ;
36555 int val4 ;
36556 int ecode4 = 0 ;
36557 int val5 ;
36558 int ecode5 = 0 ;
36559 bool val6 ;
36560 int ecode6 = 0 ;
36561 PyObject * obj0 = 0 ;
36562 PyObject * obj1 = 0 ;
36563 PyObject * obj2 = 0 ;
36564 PyObject * obj3 = 0 ;
36565 PyObject * obj4 = 0 ;
36566 PyObject * obj5 = 0 ;
36567 char * kwnames[] = {
36568 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36569 };
36570
36571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36573 if (!SWIG_IsOK(res1)) {
36574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36575 }
36576 arg1 = reinterpret_cast< wxWindow * >(argp1);
36577 ecode2 = SWIG_AsVal_int(obj1, &val2);
36578 if (!SWIG_IsOK(ecode2)) {
36579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36580 }
36581 arg2 = static_cast< int >(val2);
36582 ecode3 = SWIG_AsVal_int(obj2, &val3);
36583 if (!SWIG_IsOK(ecode3)) {
36584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36585 }
36586 arg3 = static_cast< int >(val3);
36587 ecode4 = SWIG_AsVal_int(obj3, &val4);
36588 if (!SWIG_IsOK(ecode4)) {
36589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36590 }
36591 arg4 = static_cast< int >(val4);
36592 ecode5 = SWIG_AsVal_int(obj4, &val5);
36593 if (!SWIG_IsOK(ecode5)) {
36594 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36595 }
36596 arg5 = static_cast< int >(val5);
36597 if (obj5) {
36598 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36599 if (!SWIG_IsOK(ecode6)) {
36600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36601 }
36602 arg6 = static_cast< bool >(val6);
36603 }
36604 {
36605 PyThreadState* __tstate = wxPyBeginAllowThreads();
36606 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36607 wxPyEndAllowThreads(__tstate);
36608 if (PyErr_Occurred()) SWIG_fail;
36609 }
36610 resultobj = SWIG_Py_Void();
36611 return resultobj;
36612 fail:
36613 return NULL;
36614 }
36615
36616
36617 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36618 PyObject *resultobj = 0;
36619 wxWindow *arg1 = (wxWindow *) 0 ;
36620 int arg2 ;
36621 int arg3 ;
36622 bool arg4 = (bool) true ;
36623 void *argp1 = 0 ;
36624 int res1 = 0 ;
36625 int val2 ;
36626 int ecode2 = 0 ;
36627 int val3 ;
36628 int ecode3 = 0 ;
36629 bool val4 ;
36630 int ecode4 = 0 ;
36631 PyObject * obj0 = 0 ;
36632 PyObject * obj1 = 0 ;
36633 PyObject * obj2 = 0 ;
36634 PyObject * obj3 = 0 ;
36635 char * kwnames[] = {
36636 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36637 };
36638
36639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36641 if (!SWIG_IsOK(res1)) {
36642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36643 }
36644 arg1 = reinterpret_cast< wxWindow * >(argp1);
36645 ecode2 = SWIG_AsVal_int(obj1, &val2);
36646 if (!SWIG_IsOK(ecode2)) {
36647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36648 }
36649 arg2 = static_cast< int >(val2);
36650 ecode3 = SWIG_AsVal_int(obj2, &val3);
36651 if (!SWIG_IsOK(ecode3)) {
36652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36653 }
36654 arg3 = static_cast< int >(val3);
36655 if (obj3) {
36656 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36657 if (!SWIG_IsOK(ecode4)) {
36658 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36659 }
36660 arg4 = static_cast< bool >(val4);
36661 }
36662 {
36663 PyThreadState* __tstate = wxPyBeginAllowThreads();
36664 (arg1)->SetScrollPos(arg2,arg3,arg4);
36665 wxPyEndAllowThreads(__tstate);
36666 if (PyErr_Occurred()) SWIG_fail;
36667 }
36668 resultobj = SWIG_Py_Void();
36669 return resultobj;
36670 fail:
36671 return NULL;
36672 }
36673
36674
36675 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36676 PyObject *resultobj = 0;
36677 wxWindow *arg1 = (wxWindow *) 0 ;
36678 int arg2 ;
36679 int result;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 int val2 ;
36683 int ecode2 = 0 ;
36684 PyObject * obj0 = 0 ;
36685 PyObject * obj1 = 0 ;
36686 char * kwnames[] = {
36687 (char *) "self",(char *) "orientation", NULL
36688 };
36689
36690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36692 if (!SWIG_IsOK(res1)) {
36693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36694 }
36695 arg1 = reinterpret_cast< wxWindow * >(argp1);
36696 ecode2 = SWIG_AsVal_int(obj1, &val2);
36697 if (!SWIG_IsOK(ecode2)) {
36698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36699 }
36700 arg2 = static_cast< int >(val2);
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36704 wxPyEndAllowThreads(__tstate);
36705 if (PyErr_Occurred()) SWIG_fail;
36706 }
36707 resultobj = SWIG_From_int(static_cast< int >(result));
36708 return resultobj;
36709 fail:
36710 return NULL;
36711 }
36712
36713
36714 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36715 PyObject *resultobj = 0;
36716 wxWindow *arg1 = (wxWindow *) 0 ;
36717 int arg2 ;
36718 int result;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 int val2 ;
36722 int ecode2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char * kwnames[] = {
36726 (char *) "self",(char *) "orientation", NULL
36727 };
36728
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 ecode2 = SWIG_AsVal_int(obj1, &val2);
36736 if (!SWIG_IsOK(ecode2)) {
36737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36738 }
36739 arg2 = static_cast< int >(val2);
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36743 wxPyEndAllowThreads(__tstate);
36744 if (PyErr_Occurred()) SWIG_fail;
36745 }
36746 resultobj = SWIG_From_int(static_cast< int >(result));
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj = 0;
36755 wxWindow *arg1 = (wxWindow *) 0 ;
36756 int arg2 ;
36757 int result;
36758 void *argp1 = 0 ;
36759 int res1 = 0 ;
36760 int val2 ;
36761 int ecode2 = 0 ;
36762 PyObject * obj0 = 0 ;
36763 PyObject * obj1 = 0 ;
36764 char * kwnames[] = {
36765 (char *) "self",(char *) "orientation", NULL
36766 };
36767
36768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36770 if (!SWIG_IsOK(res1)) {
36771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36772 }
36773 arg1 = reinterpret_cast< wxWindow * >(argp1);
36774 ecode2 = SWIG_AsVal_int(obj1, &val2);
36775 if (!SWIG_IsOK(ecode2)) {
36776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36777 }
36778 arg2 = static_cast< int >(val2);
36779 {
36780 PyThreadState* __tstate = wxPyBeginAllowThreads();
36781 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36782 wxPyEndAllowThreads(__tstate);
36783 if (PyErr_Occurred()) SWIG_fail;
36784 }
36785 resultobj = SWIG_From_int(static_cast< int >(result));
36786 return resultobj;
36787 fail:
36788 return NULL;
36789 }
36790
36791
36792 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36793 PyObject *resultobj = 0;
36794 wxWindow *arg1 = (wxWindow *) 0 ;
36795 int arg2 ;
36796 int arg3 ;
36797 wxRect *arg4 = (wxRect *) NULL ;
36798 void *argp1 = 0 ;
36799 int res1 = 0 ;
36800 int val2 ;
36801 int ecode2 = 0 ;
36802 int val3 ;
36803 int ecode3 = 0 ;
36804 void *argp4 = 0 ;
36805 int res4 = 0 ;
36806 PyObject * obj0 = 0 ;
36807 PyObject * obj1 = 0 ;
36808 PyObject * obj2 = 0 ;
36809 PyObject * obj3 = 0 ;
36810 char * kwnames[] = {
36811 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36812 };
36813
36814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36816 if (!SWIG_IsOK(res1)) {
36817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36818 }
36819 arg1 = reinterpret_cast< wxWindow * >(argp1);
36820 ecode2 = SWIG_AsVal_int(obj1, &val2);
36821 if (!SWIG_IsOK(ecode2)) {
36822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36823 }
36824 arg2 = static_cast< int >(val2);
36825 ecode3 = SWIG_AsVal_int(obj2, &val3);
36826 if (!SWIG_IsOK(ecode3)) {
36827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36828 }
36829 arg3 = static_cast< int >(val3);
36830 if (obj3) {
36831 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36832 if (!SWIG_IsOK(res4)) {
36833 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36834 }
36835 arg4 = reinterpret_cast< wxRect * >(argp4);
36836 }
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 resultobj = SWIG_Py_Void();
36844 return resultobj;
36845 fail:
36846 return NULL;
36847 }
36848
36849
36850 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36851 PyObject *resultobj = 0;
36852 wxWindow *arg1 = (wxWindow *) 0 ;
36853 int arg2 ;
36854 bool result;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 int val2 ;
36858 int ecode2 = 0 ;
36859 PyObject * obj0 = 0 ;
36860 PyObject * obj1 = 0 ;
36861 char * kwnames[] = {
36862 (char *) "self",(char *) "lines", NULL
36863 };
36864
36865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 ecode2 = SWIG_AsVal_int(obj1, &val2);
36872 if (!SWIG_IsOK(ecode2)) {
36873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36874 }
36875 arg2 = static_cast< int >(val2);
36876 {
36877 PyThreadState* __tstate = wxPyBeginAllowThreads();
36878 result = (bool)(arg1)->ScrollLines(arg2);
36879 wxPyEndAllowThreads(__tstate);
36880 if (PyErr_Occurred()) SWIG_fail;
36881 }
36882 {
36883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36884 }
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36892 PyObject *resultobj = 0;
36893 wxWindow *arg1 = (wxWindow *) 0 ;
36894 int arg2 ;
36895 bool result;
36896 void *argp1 = 0 ;
36897 int res1 = 0 ;
36898 int val2 ;
36899 int ecode2 = 0 ;
36900 PyObject * obj0 = 0 ;
36901 PyObject * obj1 = 0 ;
36902 char * kwnames[] = {
36903 (char *) "self",(char *) "pages", NULL
36904 };
36905
36906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36908 if (!SWIG_IsOK(res1)) {
36909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36910 }
36911 arg1 = reinterpret_cast< wxWindow * >(argp1);
36912 ecode2 = SWIG_AsVal_int(obj1, &val2);
36913 if (!SWIG_IsOK(ecode2)) {
36914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36915 }
36916 arg2 = static_cast< int >(val2);
36917 {
36918 PyThreadState* __tstate = wxPyBeginAllowThreads();
36919 result = (bool)(arg1)->ScrollPages(arg2);
36920 wxPyEndAllowThreads(__tstate);
36921 if (PyErr_Occurred()) SWIG_fail;
36922 }
36923 {
36924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36925 }
36926 return resultobj;
36927 fail:
36928 return NULL;
36929 }
36930
36931
36932 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36933 PyObject *resultobj = 0;
36934 wxWindow *arg1 = (wxWindow *) 0 ;
36935 bool result;
36936 void *argp1 = 0 ;
36937 int res1 = 0 ;
36938 PyObject *swig_obj[1] ;
36939
36940 if (!args) SWIG_fail;
36941 swig_obj[0] = args;
36942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36943 if (!SWIG_IsOK(res1)) {
36944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36945 }
36946 arg1 = reinterpret_cast< wxWindow * >(argp1);
36947 {
36948 PyThreadState* __tstate = wxPyBeginAllowThreads();
36949 result = (bool)(arg1)->LineUp();
36950 wxPyEndAllowThreads(__tstate);
36951 if (PyErr_Occurred()) SWIG_fail;
36952 }
36953 {
36954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36955 }
36956 return resultobj;
36957 fail:
36958 return NULL;
36959 }
36960
36961
36962 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36963 PyObject *resultobj = 0;
36964 wxWindow *arg1 = (wxWindow *) 0 ;
36965 bool result;
36966 void *argp1 = 0 ;
36967 int res1 = 0 ;
36968 PyObject *swig_obj[1] ;
36969
36970 if (!args) SWIG_fail;
36971 swig_obj[0] = args;
36972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36973 if (!SWIG_IsOK(res1)) {
36974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36975 }
36976 arg1 = reinterpret_cast< wxWindow * >(argp1);
36977 {
36978 PyThreadState* __tstate = wxPyBeginAllowThreads();
36979 result = (bool)(arg1)->LineDown();
36980 wxPyEndAllowThreads(__tstate);
36981 if (PyErr_Occurred()) SWIG_fail;
36982 }
36983 {
36984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36985 }
36986 return resultobj;
36987 fail:
36988 return NULL;
36989 }
36990
36991
36992 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36993 PyObject *resultobj = 0;
36994 wxWindow *arg1 = (wxWindow *) 0 ;
36995 bool result;
36996 void *argp1 = 0 ;
36997 int res1 = 0 ;
36998 PyObject *swig_obj[1] ;
36999
37000 if (!args) SWIG_fail;
37001 swig_obj[0] = args;
37002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37003 if (!SWIG_IsOK(res1)) {
37004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37005 }
37006 arg1 = reinterpret_cast< wxWindow * >(argp1);
37007 {
37008 PyThreadState* __tstate = wxPyBeginAllowThreads();
37009 result = (bool)(arg1)->PageUp();
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 {
37014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37015 }
37016 return resultobj;
37017 fail:
37018 return NULL;
37019 }
37020
37021
37022 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37023 PyObject *resultobj = 0;
37024 wxWindow *arg1 = (wxWindow *) 0 ;
37025 bool result;
37026 void *argp1 = 0 ;
37027 int res1 = 0 ;
37028 PyObject *swig_obj[1] ;
37029
37030 if (!args) SWIG_fail;
37031 swig_obj[0] = args;
37032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37033 if (!SWIG_IsOK(res1)) {
37034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37035 }
37036 arg1 = reinterpret_cast< wxWindow * >(argp1);
37037 {
37038 PyThreadState* __tstate = wxPyBeginAllowThreads();
37039 result = (bool)(arg1)->PageDown();
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 {
37044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37045 }
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj = 0;
37054 wxWindow *arg1 = (wxWindow *) 0 ;
37055 wxString *arg2 = 0 ;
37056 void *argp1 = 0 ;
37057 int res1 = 0 ;
37058 bool temp2 = false ;
37059 PyObject * obj0 = 0 ;
37060 PyObject * obj1 = 0 ;
37061 char * kwnames[] = {
37062 (char *) "self",(char *) "text", NULL
37063 };
37064
37065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37067 if (!SWIG_IsOK(res1)) {
37068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37069 }
37070 arg1 = reinterpret_cast< wxWindow * >(argp1);
37071 {
37072 arg2 = wxString_in_helper(obj1);
37073 if (arg2 == NULL) SWIG_fail;
37074 temp2 = true;
37075 }
37076 {
37077 PyThreadState* __tstate = wxPyBeginAllowThreads();
37078 (arg1)->SetHelpText((wxString const &)*arg2);
37079 wxPyEndAllowThreads(__tstate);
37080 if (PyErr_Occurred()) SWIG_fail;
37081 }
37082 resultobj = SWIG_Py_Void();
37083 {
37084 if (temp2)
37085 delete arg2;
37086 }
37087 return resultobj;
37088 fail:
37089 {
37090 if (temp2)
37091 delete arg2;
37092 }
37093 return NULL;
37094 }
37095
37096
37097 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37098 PyObject *resultobj = 0;
37099 wxWindow *arg1 = (wxWindow *) 0 ;
37100 wxString *arg2 = 0 ;
37101 void *argp1 = 0 ;
37102 int res1 = 0 ;
37103 bool temp2 = false ;
37104 PyObject * obj0 = 0 ;
37105 PyObject * obj1 = 0 ;
37106 char * kwnames[] = {
37107 (char *) "self",(char *) "text", NULL
37108 };
37109
37110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37112 if (!SWIG_IsOK(res1)) {
37113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37114 }
37115 arg1 = reinterpret_cast< wxWindow * >(argp1);
37116 {
37117 arg2 = wxString_in_helper(obj1);
37118 if (arg2 == NULL) SWIG_fail;
37119 temp2 = true;
37120 }
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 resultobj = SWIG_Py_Void();
37128 {
37129 if (temp2)
37130 delete arg2;
37131 }
37132 return resultobj;
37133 fail:
37134 {
37135 if (temp2)
37136 delete arg2;
37137 }
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37143 PyObject *resultobj = 0;
37144 wxWindow *arg1 = (wxWindow *) 0 ;
37145 wxPoint *arg2 = 0 ;
37146 wxHelpEvent::Origin arg3 ;
37147 wxString result;
37148 void *argp1 = 0 ;
37149 int res1 = 0 ;
37150 wxPoint temp2 ;
37151 void *argp3 ;
37152 int res3 = 0 ;
37153 PyObject * obj0 = 0 ;
37154 PyObject * obj1 = 0 ;
37155 PyObject * obj2 = 0 ;
37156 char * kwnames[] = {
37157 (char *) "self",(char *) "pt",(char *) "origin", NULL
37158 };
37159
37160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37162 if (!SWIG_IsOK(res1)) {
37163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37164 }
37165 arg1 = reinterpret_cast< wxWindow * >(argp1);
37166 {
37167 arg2 = &temp2;
37168 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37169 }
37170 {
37171 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37172 if (!SWIG_IsOK(res3)) {
37173 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37174 }
37175 if (!argp3) {
37176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37177 } else {
37178 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37179 arg3 = *temp;
37180 if (SWIG_IsNewObj(res3)) delete temp;
37181 }
37182 }
37183 {
37184 PyThreadState* __tstate = wxPyBeginAllowThreads();
37185 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37186 wxPyEndAllowThreads(__tstate);
37187 if (PyErr_Occurred()) SWIG_fail;
37188 }
37189 {
37190 #if wxUSE_UNICODE
37191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37192 #else
37193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37194 #endif
37195 }
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37203 PyObject *resultobj = 0;
37204 wxWindow *arg1 = (wxWindow *) 0 ;
37205 wxString result;
37206 void *argp1 = 0 ;
37207 int res1 = 0 ;
37208 PyObject *swig_obj[1] ;
37209
37210 if (!args) SWIG_fail;
37211 swig_obj[0] = args;
37212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37213 if (!SWIG_IsOK(res1)) {
37214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37215 }
37216 arg1 = reinterpret_cast< wxWindow * >(argp1);
37217 {
37218 PyThreadState* __tstate = wxPyBeginAllowThreads();
37219 result = ((wxWindow const *)arg1)->GetHelpText();
37220 wxPyEndAllowThreads(__tstate);
37221 if (PyErr_Occurred()) SWIG_fail;
37222 }
37223 {
37224 #if wxUSE_UNICODE
37225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37226 #else
37227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37228 #endif
37229 }
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37237 PyObject *resultobj = 0;
37238 wxWindow *arg1 = (wxWindow *) 0 ;
37239 wxString *arg2 = 0 ;
37240 void *argp1 = 0 ;
37241 int res1 = 0 ;
37242 bool temp2 = false ;
37243 PyObject * obj0 = 0 ;
37244 PyObject * obj1 = 0 ;
37245 char * kwnames[] = {
37246 (char *) "self",(char *) "tip", NULL
37247 };
37248
37249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37253 }
37254 arg1 = reinterpret_cast< wxWindow * >(argp1);
37255 {
37256 arg2 = wxString_in_helper(obj1);
37257 if (arg2 == NULL) SWIG_fail;
37258 temp2 = true;
37259 }
37260 {
37261 PyThreadState* __tstate = wxPyBeginAllowThreads();
37262 (arg1)->SetToolTip((wxString const &)*arg2);
37263 wxPyEndAllowThreads(__tstate);
37264 if (PyErr_Occurred()) SWIG_fail;
37265 }
37266 resultobj = SWIG_Py_Void();
37267 {
37268 if (temp2)
37269 delete arg2;
37270 }
37271 return resultobj;
37272 fail:
37273 {
37274 if (temp2)
37275 delete arg2;
37276 }
37277 return NULL;
37278 }
37279
37280
37281 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj = 0;
37283 wxWindow *arg1 = (wxWindow *) 0 ;
37284 wxToolTip *arg2 = (wxToolTip *) 0 ;
37285 void *argp1 = 0 ;
37286 int res1 = 0 ;
37287 int res2 = 0 ;
37288 PyObject * obj0 = 0 ;
37289 PyObject * obj1 = 0 ;
37290 char * kwnames[] = {
37291 (char *) "self",(char *) "tip", NULL
37292 };
37293
37294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37296 if (!SWIG_IsOK(res1)) {
37297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37298 }
37299 arg1 = reinterpret_cast< wxWindow * >(argp1);
37300 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37301 if (!SWIG_IsOK(res2)) {
37302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37303 }
37304 {
37305 PyThreadState* __tstate = wxPyBeginAllowThreads();
37306 (arg1)->SetToolTip(arg2);
37307 wxPyEndAllowThreads(__tstate);
37308 if (PyErr_Occurred()) SWIG_fail;
37309 }
37310 resultobj = SWIG_Py_Void();
37311 return resultobj;
37312 fail:
37313 return NULL;
37314 }
37315
37316
37317 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37318 PyObject *resultobj = 0;
37319 wxWindow *arg1 = (wxWindow *) 0 ;
37320 wxToolTip *result = 0 ;
37321 void *argp1 = 0 ;
37322 int res1 = 0 ;
37323 PyObject *swig_obj[1] ;
37324
37325 if (!args) SWIG_fail;
37326 swig_obj[0] = args;
37327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37328 if (!SWIG_IsOK(res1)) {
37329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37330 }
37331 arg1 = reinterpret_cast< wxWindow * >(argp1);
37332 {
37333 PyThreadState* __tstate = wxPyBeginAllowThreads();
37334 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37335 wxPyEndAllowThreads(__tstate);
37336 if (PyErr_Occurred()) SWIG_fail;
37337 }
37338 {
37339 resultobj = wxPyMake_wxObject(result, (bool)0);
37340 }
37341 return resultobj;
37342 fail:
37343 return NULL;
37344 }
37345
37346
37347 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37348 PyObject *resultobj = 0;
37349 wxWindow *arg1 = (wxWindow *) 0 ;
37350 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37351 void *argp1 = 0 ;
37352 int res1 = 0 ;
37353 int res2 = 0 ;
37354 PyObject * obj0 = 0 ;
37355 PyObject * obj1 = 0 ;
37356 char * kwnames[] = {
37357 (char *) "self",(char *) "dropTarget", NULL
37358 };
37359
37360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37367 if (!SWIG_IsOK(res2)) {
37368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37369 }
37370 {
37371 PyThreadState* __tstate = wxPyBeginAllowThreads();
37372 (arg1)->SetDropTarget(arg2);
37373 wxPyEndAllowThreads(__tstate);
37374 if (PyErr_Occurred()) SWIG_fail;
37375 }
37376 resultobj = SWIG_Py_Void();
37377 return resultobj;
37378 fail:
37379 return NULL;
37380 }
37381
37382
37383 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37384 PyObject *resultobj = 0;
37385 wxWindow *arg1 = (wxWindow *) 0 ;
37386 wxPyDropTarget *result = 0 ;
37387 void *argp1 = 0 ;
37388 int res1 = 0 ;
37389 PyObject *swig_obj[1] ;
37390
37391 if (!args) SWIG_fail;
37392 swig_obj[0] = args;
37393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37394 if (!SWIG_IsOK(res1)) {
37395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37396 }
37397 arg1 = reinterpret_cast< wxWindow * >(argp1);
37398 {
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37401 wxPyEndAllowThreads(__tstate);
37402 if (PyErr_Occurred()) SWIG_fail;
37403 }
37404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37405 return resultobj;
37406 fail:
37407 return NULL;
37408 }
37409
37410
37411 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37412 PyObject *resultobj = 0;
37413 wxWindow *arg1 = (wxWindow *) 0 ;
37414 bool arg2 ;
37415 void *argp1 = 0 ;
37416 int res1 = 0 ;
37417 bool val2 ;
37418 int ecode2 = 0 ;
37419 PyObject * obj0 = 0 ;
37420 PyObject * obj1 = 0 ;
37421 char * kwnames[] = {
37422 (char *) "self",(char *) "accept", NULL
37423 };
37424
37425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37427 if (!SWIG_IsOK(res1)) {
37428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37429 }
37430 arg1 = reinterpret_cast< wxWindow * >(argp1);
37431 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37432 if (!SWIG_IsOK(ecode2)) {
37433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37434 }
37435 arg2 = static_cast< bool >(val2);
37436 {
37437 PyThreadState* __tstate = wxPyBeginAllowThreads();
37438 (arg1)->DragAcceptFiles(arg2);
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 resultobj = SWIG_Py_Void();
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37450 PyObject *resultobj = 0;
37451 wxWindow *arg1 = (wxWindow *) 0 ;
37452 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37453 void *argp1 = 0 ;
37454 int res1 = 0 ;
37455 int res2 = 0 ;
37456 PyObject * obj0 = 0 ;
37457 PyObject * obj1 = 0 ;
37458 char * kwnames[] = {
37459 (char *) "self",(char *) "constraints", NULL
37460 };
37461
37462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37464 if (!SWIG_IsOK(res1)) {
37465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37466 }
37467 arg1 = reinterpret_cast< wxWindow * >(argp1);
37468 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37469 if (!SWIG_IsOK(res2)) {
37470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37471 }
37472 {
37473 PyThreadState* __tstate = wxPyBeginAllowThreads();
37474 (arg1)->SetConstraints(arg2);
37475 wxPyEndAllowThreads(__tstate);
37476 if (PyErr_Occurred()) SWIG_fail;
37477 }
37478 resultobj = SWIG_Py_Void();
37479 return resultobj;
37480 fail:
37481 return NULL;
37482 }
37483
37484
37485 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37486 PyObject *resultobj = 0;
37487 wxWindow *arg1 = (wxWindow *) 0 ;
37488 wxLayoutConstraints *result = 0 ;
37489 void *argp1 = 0 ;
37490 int res1 = 0 ;
37491 PyObject *swig_obj[1] ;
37492
37493 if (!args) SWIG_fail;
37494 swig_obj[0] = args;
37495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37496 if (!SWIG_IsOK(res1)) {
37497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37498 }
37499 arg1 = reinterpret_cast< wxWindow * >(argp1);
37500 {
37501 PyThreadState* __tstate = wxPyBeginAllowThreads();
37502 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37503 wxPyEndAllowThreads(__tstate);
37504 if (PyErr_Occurred()) SWIG_fail;
37505 }
37506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37507 return resultobj;
37508 fail:
37509 return NULL;
37510 }
37511
37512
37513 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37514 PyObject *resultobj = 0;
37515 wxWindow *arg1 = (wxWindow *) 0 ;
37516 bool arg2 ;
37517 void *argp1 = 0 ;
37518 int res1 = 0 ;
37519 bool val2 ;
37520 int ecode2 = 0 ;
37521 PyObject * obj0 = 0 ;
37522 PyObject * obj1 = 0 ;
37523 char * kwnames[] = {
37524 (char *) "self",(char *) "autoLayout", NULL
37525 };
37526
37527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37529 if (!SWIG_IsOK(res1)) {
37530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37531 }
37532 arg1 = reinterpret_cast< wxWindow * >(argp1);
37533 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37534 if (!SWIG_IsOK(ecode2)) {
37535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37536 }
37537 arg2 = static_cast< bool >(val2);
37538 {
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 (arg1)->SetAutoLayout(arg2);
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 resultobj = SWIG_Py_Void();
37545 return resultobj;
37546 fail:
37547 return NULL;
37548 }
37549
37550
37551 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37552 PyObject *resultobj = 0;
37553 wxWindow *arg1 = (wxWindow *) 0 ;
37554 bool result;
37555 void *argp1 = 0 ;
37556 int res1 = 0 ;
37557 PyObject *swig_obj[1] ;
37558
37559 if (!args) SWIG_fail;
37560 swig_obj[0] = args;
37561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37562 if (!SWIG_IsOK(res1)) {
37563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37564 }
37565 arg1 = reinterpret_cast< wxWindow * >(argp1);
37566 {
37567 PyThreadState* __tstate = wxPyBeginAllowThreads();
37568 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37569 wxPyEndAllowThreads(__tstate);
37570 if (PyErr_Occurred()) SWIG_fail;
37571 }
37572 {
37573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37574 }
37575 return resultobj;
37576 fail:
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37582 PyObject *resultobj = 0;
37583 wxWindow *arg1 = (wxWindow *) 0 ;
37584 bool result;
37585 void *argp1 = 0 ;
37586 int res1 = 0 ;
37587 PyObject *swig_obj[1] ;
37588
37589 if (!args) SWIG_fail;
37590 swig_obj[0] = args;
37591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37592 if (!SWIG_IsOK(res1)) {
37593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37594 }
37595 arg1 = reinterpret_cast< wxWindow * >(argp1);
37596 {
37597 PyThreadState* __tstate = wxPyBeginAllowThreads();
37598 result = (bool)(arg1)->Layout();
37599 wxPyEndAllowThreads(__tstate);
37600 if (PyErr_Occurred()) SWIG_fail;
37601 }
37602 {
37603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37604 }
37605 return resultobj;
37606 fail:
37607 return NULL;
37608 }
37609
37610
37611 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37612 PyObject *resultobj = 0;
37613 wxWindow *arg1 = (wxWindow *) 0 ;
37614 wxSizer *arg2 = (wxSizer *) 0 ;
37615 bool arg3 = (bool) true ;
37616 void *argp1 = 0 ;
37617 int res1 = 0 ;
37618 int res2 = 0 ;
37619 bool val3 ;
37620 int ecode3 = 0 ;
37621 PyObject * obj0 = 0 ;
37622 PyObject * obj1 = 0 ;
37623 PyObject * obj2 = 0 ;
37624 char * kwnames[] = {
37625 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37626 };
37627
37628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37632 }
37633 arg1 = reinterpret_cast< wxWindow * >(argp1);
37634 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37635 if (!SWIG_IsOK(res2)) {
37636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37637 }
37638 if (obj2) {
37639 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37640 if (!SWIG_IsOK(ecode3)) {
37641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37642 }
37643 arg3 = static_cast< bool >(val3);
37644 }
37645 {
37646 PyThreadState* __tstate = wxPyBeginAllowThreads();
37647 (arg1)->SetSizer(arg2,arg3);
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 resultobj = SWIG_Py_Void();
37652 return resultobj;
37653 fail:
37654 return NULL;
37655 }
37656
37657
37658 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37659 PyObject *resultobj = 0;
37660 wxWindow *arg1 = (wxWindow *) 0 ;
37661 wxSizer *arg2 = (wxSizer *) 0 ;
37662 bool arg3 = (bool) true ;
37663 void *argp1 = 0 ;
37664 int res1 = 0 ;
37665 int res2 = 0 ;
37666 bool val3 ;
37667 int ecode3 = 0 ;
37668 PyObject * obj0 = 0 ;
37669 PyObject * obj1 = 0 ;
37670 PyObject * obj2 = 0 ;
37671 char * kwnames[] = {
37672 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37673 };
37674
37675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37677 if (!SWIG_IsOK(res1)) {
37678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37679 }
37680 arg1 = reinterpret_cast< wxWindow * >(argp1);
37681 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37682 if (!SWIG_IsOK(res2)) {
37683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37684 }
37685 if (obj2) {
37686 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37687 if (!SWIG_IsOK(ecode3)) {
37688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37689 }
37690 arg3 = static_cast< bool >(val3);
37691 }
37692 {
37693 PyThreadState* __tstate = wxPyBeginAllowThreads();
37694 (arg1)->SetSizerAndFit(arg2,arg3);
37695 wxPyEndAllowThreads(__tstate);
37696 if (PyErr_Occurred()) SWIG_fail;
37697 }
37698 resultobj = SWIG_Py_Void();
37699 return resultobj;
37700 fail:
37701 return NULL;
37702 }
37703
37704
37705 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37706 PyObject *resultobj = 0;
37707 wxWindow *arg1 = (wxWindow *) 0 ;
37708 wxSizer *result = 0 ;
37709 void *argp1 = 0 ;
37710 int res1 = 0 ;
37711 PyObject *swig_obj[1] ;
37712
37713 if (!args) SWIG_fail;
37714 swig_obj[0] = args;
37715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37716 if (!SWIG_IsOK(res1)) {
37717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37718 }
37719 arg1 = reinterpret_cast< wxWindow * >(argp1);
37720 {
37721 PyThreadState* __tstate = wxPyBeginAllowThreads();
37722 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37723 wxPyEndAllowThreads(__tstate);
37724 if (PyErr_Occurred()) SWIG_fail;
37725 }
37726 {
37727 resultobj = wxPyMake_wxObject(result, (bool)0);
37728 }
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37736 PyObject *resultobj = 0;
37737 wxWindow *arg1 = (wxWindow *) 0 ;
37738 wxSizer *arg2 = (wxSizer *) 0 ;
37739 void *argp1 = 0 ;
37740 int res1 = 0 ;
37741 void *argp2 = 0 ;
37742 int res2 = 0 ;
37743 PyObject * obj0 = 0 ;
37744 PyObject * obj1 = 0 ;
37745 char * kwnames[] = {
37746 (char *) "self",(char *) "sizer", NULL
37747 };
37748
37749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37751 if (!SWIG_IsOK(res1)) {
37752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37753 }
37754 arg1 = reinterpret_cast< wxWindow * >(argp1);
37755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37756 if (!SWIG_IsOK(res2)) {
37757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37758 }
37759 arg2 = reinterpret_cast< wxSizer * >(argp2);
37760 {
37761 PyThreadState* __tstate = wxPyBeginAllowThreads();
37762 (arg1)->SetContainingSizer(arg2);
37763 wxPyEndAllowThreads(__tstate);
37764 if (PyErr_Occurred()) SWIG_fail;
37765 }
37766 resultobj = SWIG_Py_Void();
37767 return resultobj;
37768 fail:
37769 return NULL;
37770 }
37771
37772
37773 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37774 PyObject *resultobj = 0;
37775 wxWindow *arg1 = (wxWindow *) 0 ;
37776 wxSizer *result = 0 ;
37777 void *argp1 = 0 ;
37778 int res1 = 0 ;
37779 PyObject *swig_obj[1] ;
37780
37781 if (!args) SWIG_fail;
37782 swig_obj[0] = args;
37783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37784 if (!SWIG_IsOK(res1)) {
37785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37786 }
37787 arg1 = reinterpret_cast< wxWindow * >(argp1);
37788 {
37789 PyThreadState* __tstate = wxPyBeginAllowThreads();
37790 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37791 wxPyEndAllowThreads(__tstate);
37792 if (PyErr_Occurred()) SWIG_fail;
37793 }
37794 {
37795 resultobj = wxPyMake_wxObject(result, (bool)0);
37796 }
37797 return resultobj;
37798 fail:
37799 return NULL;
37800 }
37801
37802
37803 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37804 PyObject *resultobj = 0;
37805 wxWindow *arg1 = (wxWindow *) 0 ;
37806 void *argp1 = 0 ;
37807 int res1 = 0 ;
37808 PyObject *swig_obj[1] ;
37809
37810 if (!args) SWIG_fail;
37811 swig_obj[0] = args;
37812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37813 if (!SWIG_IsOK(res1)) {
37814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37815 }
37816 arg1 = reinterpret_cast< wxWindow * >(argp1);
37817 {
37818 PyThreadState* __tstate = wxPyBeginAllowThreads();
37819 (arg1)->InheritAttributes();
37820 wxPyEndAllowThreads(__tstate);
37821 if (PyErr_Occurred()) SWIG_fail;
37822 }
37823 resultobj = SWIG_Py_Void();
37824 return resultobj;
37825 fail:
37826 return NULL;
37827 }
37828
37829
37830 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37831 PyObject *resultobj = 0;
37832 wxWindow *arg1 = (wxWindow *) 0 ;
37833 bool result;
37834 void *argp1 = 0 ;
37835 int res1 = 0 ;
37836 PyObject *swig_obj[1] ;
37837
37838 if (!args) SWIG_fail;
37839 swig_obj[0] = args;
37840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37841 if (!SWIG_IsOK(res1)) {
37842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37843 }
37844 arg1 = reinterpret_cast< wxWindow * >(argp1);
37845 {
37846 PyThreadState* __tstate = wxPyBeginAllowThreads();
37847 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37848 wxPyEndAllowThreads(__tstate);
37849 if (PyErr_Occurred()) SWIG_fail;
37850 }
37851 {
37852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37853 }
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 wxWindow *arg1 = (wxWindow *) 0 ;
37863 bool result;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 PyObject *swig_obj[1] ;
37867
37868 if (!args) SWIG_fail;
37869 swig_obj[0] = args;
37870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37873 }
37874 arg1 = reinterpret_cast< wxWindow * >(argp1);
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = (bool)(arg1)->CanSetTransparent();
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37883 }
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37891 PyObject *resultobj = 0;
37892 wxWindow *arg1 = (wxWindow *) 0 ;
37893 byte arg2 ;
37894 bool result;
37895 void *argp1 = 0 ;
37896 int res1 = 0 ;
37897 unsigned char val2 ;
37898 int ecode2 = 0 ;
37899 PyObject * obj0 = 0 ;
37900 PyObject * obj1 = 0 ;
37901 char * kwnames[] = {
37902 (char *) "self",(char *) "alpha", NULL
37903 };
37904
37905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37907 if (!SWIG_IsOK(res1)) {
37908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37909 }
37910 arg1 = reinterpret_cast< wxWindow * >(argp1);
37911 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37912 if (!SWIG_IsOK(ecode2)) {
37913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37914 }
37915 arg2 = static_cast< byte >(val2);
37916 {
37917 PyThreadState* __tstate = wxPyBeginAllowThreads();
37918 result = (bool)(arg1)->SetTransparent(arg2);
37919 wxPyEndAllowThreads(__tstate);
37920 if (PyErr_Occurred()) SWIG_fail;
37921 }
37922 {
37923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37924 }
37925 return resultobj;
37926 fail:
37927 return NULL;
37928 }
37929
37930
37931 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37932 PyObject *obj;
37933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37934 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37935 return SWIG_Py_Void();
37936 }
37937
37938 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37939 return SWIG_Python_InitShadowInstance(args);
37940 }
37941
37942 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = 0;
37944 long arg1 ;
37945 wxWindow *arg2 = (wxWindow *) NULL ;
37946 wxWindow *result = 0 ;
37947 long val1 ;
37948 int ecode1 = 0 ;
37949 void *argp2 = 0 ;
37950 int res2 = 0 ;
37951 PyObject * obj0 = 0 ;
37952 PyObject * obj1 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "id",(char *) "parent", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37958 ecode1 = SWIG_AsVal_long(obj0, &val1);
37959 if (!SWIG_IsOK(ecode1)) {
37960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37961 }
37962 arg1 = static_cast< long >(val1);
37963 if (obj1) {
37964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37965 if (!SWIG_IsOK(res2)) {
37966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37967 }
37968 arg2 = reinterpret_cast< wxWindow * >(argp2);
37969 }
37970 {
37971 if (!wxPyCheckForApp()) SWIG_fail;
37972 PyThreadState* __tstate = wxPyBeginAllowThreads();
37973 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37974 wxPyEndAllowThreads(__tstate);
37975 if (PyErr_Occurred()) SWIG_fail;
37976 }
37977 {
37978 resultobj = wxPyMake_wxObject(result, 0);
37979 }
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37987 PyObject *resultobj = 0;
37988 wxString *arg1 = 0 ;
37989 wxWindow *arg2 = (wxWindow *) NULL ;
37990 wxWindow *result = 0 ;
37991 bool temp1 = false ;
37992 void *argp2 = 0 ;
37993 int res2 = 0 ;
37994 PyObject * obj0 = 0 ;
37995 PyObject * obj1 = 0 ;
37996 char * kwnames[] = {
37997 (char *) "name",(char *) "parent", NULL
37998 };
37999
38000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38001 {
38002 arg1 = wxString_in_helper(obj0);
38003 if (arg1 == NULL) SWIG_fail;
38004 temp1 = true;
38005 }
38006 if (obj1) {
38007 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38008 if (!SWIG_IsOK(res2)) {
38009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38010 }
38011 arg2 = reinterpret_cast< wxWindow * >(argp2);
38012 }
38013 {
38014 if (!wxPyCheckForApp()) SWIG_fail;
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 {
38021 resultobj = wxPyMake_wxObject(result, 0);
38022 }
38023 {
38024 if (temp1)
38025 delete arg1;
38026 }
38027 return resultobj;
38028 fail:
38029 {
38030 if (temp1)
38031 delete arg1;
38032 }
38033 return NULL;
38034 }
38035
38036
38037 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38038 PyObject *resultobj = 0;
38039 wxString *arg1 = 0 ;
38040 wxWindow *arg2 = (wxWindow *) NULL ;
38041 wxWindow *result = 0 ;
38042 bool temp1 = false ;
38043 void *argp2 = 0 ;
38044 int res2 = 0 ;
38045 PyObject * obj0 = 0 ;
38046 PyObject * obj1 = 0 ;
38047 char * kwnames[] = {
38048 (char *) "label",(char *) "parent", NULL
38049 };
38050
38051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38052 {
38053 arg1 = wxString_in_helper(obj0);
38054 if (arg1 == NULL) SWIG_fail;
38055 temp1 = true;
38056 }
38057 if (obj1) {
38058 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38059 if (!SWIG_IsOK(res2)) {
38060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38061 }
38062 arg2 = reinterpret_cast< wxWindow * >(argp2);
38063 }
38064 {
38065 if (!wxPyCheckForApp()) SWIG_fail;
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 {
38072 resultobj = wxPyMake_wxObject(result, 0);
38073 }
38074 {
38075 if (temp1)
38076 delete arg1;
38077 }
38078 return resultobj;
38079 fail:
38080 {
38081 if (temp1)
38082 delete arg1;
38083 }
38084 return NULL;
38085 }
38086
38087
38088 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38089 PyObject *resultobj = 0;
38090 wxWindow *arg1 = (wxWindow *) 0 ;
38091 unsigned long arg2 ;
38092 wxWindow *result = 0 ;
38093 void *argp1 = 0 ;
38094 int res1 = 0 ;
38095 unsigned long val2 ;
38096 int ecode2 = 0 ;
38097 PyObject * obj0 = 0 ;
38098 PyObject * obj1 = 0 ;
38099 char * kwnames[] = {
38100 (char *) "parent",(char *) "_hWnd", NULL
38101 };
38102
38103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38105 if (!SWIG_IsOK(res1)) {
38106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38107 }
38108 arg1 = reinterpret_cast< wxWindow * >(argp1);
38109 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38110 if (!SWIG_IsOK(ecode2)) {
38111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38112 }
38113 arg2 = static_cast< unsigned long >(val2);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 {
38121 resultobj = wxPyMake_wxObject(result, 0);
38122 }
38123 return resultobj;
38124 fail:
38125 return NULL;
38126 }
38127
38128
38129 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38130 PyObject *resultobj = 0;
38131 PyObject *result = 0 ;
38132
38133 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38134 {
38135 PyThreadState* __tstate = wxPyBeginAllowThreads();
38136 result = (PyObject *)GetTopLevelWindows();
38137 wxPyEndAllowThreads(__tstate);
38138 if (PyErr_Occurred()) SWIG_fail;
38139 }
38140 resultobj = result;
38141 return resultobj;
38142 fail:
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38148 PyObject *resultobj = 0;
38149 wxValidator *result = 0 ;
38150
38151 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38152 {
38153 PyThreadState* __tstate = wxPyBeginAllowThreads();
38154 result = (wxValidator *)new wxValidator();
38155 wxPyEndAllowThreads(__tstate);
38156 if (PyErr_Occurred()) SWIG_fail;
38157 }
38158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38159 return resultobj;
38160 fail:
38161 return NULL;
38162 }
38163
38164
38165 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38166 PyObject *resultobj = 0;
38167 wxValidator *arg1 = (wxValidator *) 0 ;
38168 wxValidator *result = 0 ;
38169 void *argp1 = 0 ;
38170 int res1 = 0 ;
38171 PyObject *swig_obj[1] ;
38172
38173 if (!args) SWIG_fail;
38174 swig_obj[0] = args;
38175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38176 if (!SWIG_IsOK(res1)) {
38177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38178 }
38179 arg1 = reinterpret_cast< wxValidator * >(argp1);
38180 {
38181 PyThreadState* __tstate = wxPyBeginAllowThreads();
38182 result = (wxValidator *)(arg1)->Clone();
38183 wxPyEndAllowThreads(__tstate);
38184 if (PyErr_Occurred()) SWIG_fail;
38185 }
38186 {
38187 resultobj = wxPyMake_wxObject(result, 0);
38188 }
38189 return resultobj;
38190 fail:
38191 return NULL;
38192 }
38193
38194
38195 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38196 PyObject *resultobj = 0;
38197 wxValidator *arg1 = (wxValidator *) 0 ;
38198 wxWindow *arg2 = (wxWindow *) 0 ;
38199 bool result;
38200 void *argp1 = 0 ;
38201 int res1 = 0 ;
38202 void *argp2 = 0 ;
38203 int res2 = 0 ;
38204 PyObject * obj0 = 0 ;
38205 PyObject * obj1 = 0 ;
38206 char * kwnames[] = {
38207 (char *) "self",(char *) "parent", NULL
38208 };
38209
38210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38212 if (!SWIG_IsOK(res1)) {
38213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38214 }
38215 arg1 = reinterpret_cast< wxValidator * >(argp1);
38216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38217 if (!SWIG_IsOK(res2)) {
38218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38219 }
38220 arg2 = reinterpret_cast< wxWindow * >(argp2);
38221 {
38222 PyThreadState* __tstate = wxPyBeginAllowThreads();
38223 result = (bool)(arg1)->Validate(arg2);
38224 wxPyEndAllowThreads(__tstate);
38225 if (PyErr_Occurred()) SWIG_fail;
38226 }
38227 {
38228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38229 }
38230 return resultobj;
38231 fail:
38232 return NULL;
38233 }
38234
38235
38236 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38237 PyObject *resultobj = 0;
38238 wxValidator *arg1 = (wxValidator *) 0 ;
38239 bool result;
38240 void *argp1 = 0 ;
38241 int res1 = 0 ;
38242 PyObject *swig_obj[1] ;
38243
38244 if (!args) SWIG_fail;
38245 swig_obj[0] = args;
38246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38247 if (!SWIG_IsOK(res1)) {
38248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38249 }
38250 arg1 = reinterpret_cast< wxValidator * >(argp1);
38251 {
38252 PyThreadState* __tstate = wxPyBeginAllowThreads();
38253 result = (bool)(arg1)->TransferToWindow();
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 {
38258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38259 }
38260 return resultobj;
38261 fail:
38262 return NULL;
38263 }
38264
38265
38266 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38267 PyObject *resultobj = 0;
38268 wxValidator *arg1 = (wxValidator *) 0 ;
38269 bool result;
38270 void *argp1 = 0 ;
38271 int res1 = 0 ;
38272 PyObject *swig_obj[1] ;
38273
38274 if (!args) SWIG_fail;
38275 swig_obj[0] = args;
38276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38277 if (!SWIG_IsOK(res1)) {
38278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38279 }
38280 arg1 = reinterpret_cast< wxValidator * >(argp1);
38281 {
38282 PyThreadState* __tstate = wxPyBeginAllowThreads();
38283 result = (bool)(arg1)->TransferFromWindow();
38284 wxPyEndAllowThreads(__tstate);
38285 if (PyErr_Occurred()) SWIG_fail;
38286 }
38287 {
38288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38289 }
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38297 PyObject *resultobj = 0;
38298 wxValidator *arg1 = (wxValidator *) 0 ;
38299 wxWindow *result = 0 ;
38300 void *argp1 = 0 ;
38301 int res1 = 0 ;
38302 PyObject *swig_obj[1] ;
38303
38304 if (!args) SWIG_fail;
38305 swig_obj[0] = args;
38306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38307 if (!SWIG_IsOK(res1)) {
38308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38309 }
38310 arg1 = reinterpret_cast< wxValidator * >(argp1);
38311 {
38312 PyThreadState* __tstate = wxPyBeginAllowThreads();
38313 result = (wxWindow *)(arg1)->GetWindow();
38314 wxPyEndAllowThreads(__tstate);
38315 if (PyErr_Occurred()) SWIG_fail;
38316 }
38317 {
38318 resultobj = wxPyMake_wxObject(result, 0);
38319 }
38320 return resultobj;
38321 fail:
38322 return NULL;
38323 }
38324
38325
38326 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38327 PyObject *resultobj = 0;
38328 wxValidator *arg1 = (wxValidator *) 0 ;
38329 wxWindow *arg2 = (wxWindow *) 0 ;
38330 void *argp1 = 0 ;
38331 int res1 = 0 ;
38332 void *argp2 = 0 ;
38333 int res2 = 0 ;
38334 PyObject * obj0 = 0 ;
38335 PyObject * obj1 = 0 ;
38336 char * kwnames[] = {
38337 (char *) "self",(char *) "window", NULL
38338 };
38339
38340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38342 if (!SWIG_IsOK(res1)) {
38343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38344 }
38345 arg1 = reinterpret_cast< wxValidator * >(argp1);
38346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38347 if (!SWIG_IsOK(res2)) {
38348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38349 }
38350 arg2 = reinterpret_cast< wxWindow * >(argp2);
38351 {
38352 PyThreadState* __tstate = wxPyBeginAllowThreads();
38353 (arg1)->SetWindow(arg2);
38354 wxPyEndAllowThreads(__tstate);
38355 if (PyErr_Occurred()) SWIG_fail;
38356 }
38357 resultobj = SWIG_Py_Void();
38358 return resultobj;
38359 fail:
38360 return NULL;
38361 }
38362
38363
38364 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38365 PyObject *resultobj = 0;
38366 bool result;
38367
38368 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38369 {
38370 PyThreadState* __tstate = wxPyBeginAllowThreads();
38371 result = (bool)wxValidator::IsSilent();
38372 wxPyEndAllowThreads(__tstate);
38373 if (PyErr_Occurred()) SWIG_fail;
38374 }
38375 {
38376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38377 }
38378 return resultobj;
38379 fail:
38380 return NULL;
38381 }
38382
38383
38384 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38385 PyObject *resultobj = 0;
38386 int arg1 = (int) true ;
38387 int val1 ;
38388 int ecode1 = 0 ;
38389 PyObject * obj0 = 0 ;
38390 char * kwnames[] = {
38391 (char *) "doIt", NULL
38392 };
38393
38394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38395 if (obj0) {
38396 ecode1 = SWIG_AsVal_int(obj0, &val1);
38397 if (!SWIG_IsOK(ecode1)) {
38398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38399 }
38400 arg1 = static_cast< int >(val1);
38401 }
38402 {
38403 PyThreadState* __tstate = wxPyBeginAllowThreads();
38404 wxValidator::SetBellOnError(arg1);
38405 wxPyEndAllowThreads(__tstate);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 }
38408 resultobj = SWIG_Py_Void();
38409 return resultobj;
38410 fail:
38411 return NULL;
38412 }
38413
38414
38415 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38416 PyObject *obj;
38417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38418 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38419 return SWIG_Py_Void();
38420 }
38421
38422 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38423 return SWIG_Python_InitShadowInstance(args);
38424 }
38425
38426 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38427 PyObject *resultobj = 0;
38428 wxPyValidator *result = 0 ;
38429
38430 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 result = (wxPyValidator *)new wxPyValidator();
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38438 return resultobj;
38439 fail:
38440 return NULL;
38441 }
38442
38443
38444 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38445 PyObject *resultobj = 0;
38446 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38447 PyObject *arg2 = (PyObject *) 0 ;
38448 PyObject *arg3 = (PyObject *) 0 ;
38449 int arg4 = (int) true ;
38450 void *argp1 = 0 ;
38451 int res1 = 0 ;
38452 int val4 ;
38453 int ecode4 = 0 ;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 PyObject * obj2 = 0 ;
38457 PyObject * obj3 = 0 ;
38458 char * kwnames[] = {
38459 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38460 };
38461
38462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38464 if (!SWIG_IsOK(res1)) {
38465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38466 }
38467 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38468 arg2 = obj1;
38469 arg3 = obj2;
38470 if (obj3) {
38471 ecode4 = SWIG_AsVal_int(obj3, &val4);
38472 if (!SWIG_IsOK(ecode4)) {
38473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38474 }
38475 arg4 = static_cast< int >(val4);
38476 }
38477 {
38478 PyThreadState* __tstate = wxPyBeginAllowThreads();
38479 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38480 wxPyEndAllowThreads(__tstate);
38481 if (PyErr_Occurred()) SWIG_fail;
38482 }
38483 resultobj = SWIG_Py_Void();
38484 return resultobj;
38485 fail:
38486 return NULL;
38487 }
38488
38489
38490 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38491 PyObject *obj;
38492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38493 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38494 return SWIG_Py_Void();
38495 }
38496
38497 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38498 return SWIG_Python_InitShadowInstance(args);
38499 }
38500
38501 SWIGINTERN int DefaultValidator_set(PyObject *) {
38502 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38503 return 1;
38504 }
38505
38506
38507 SWIGINTERN PyObject *DefaultValidator_get(void) {
38508 PyObject *pyobj = 0;
38509
38510 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38511 return pyobj;
38512 }
38513
38514
38515 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38516 PyObject *resultobj = 0;
38517 wxString const &arg1_defvalue = wxPyEmptyString ;
38518 wxString *arg1 = (wxString *) &arg1_defvalue ;
38519 long arg2 = (long) 0 ;
38520 wxMenu *result = 0 ;
38521 bool temp1 = false ;
38522 long val2 ;
38523 int ecode2 = 0 ;
38524 PyObject * obj0 = 0 ;
38525 PyObject * obj1 = 0 ;
38526 char * kwnames[] = {
38527 (char *) "title",(char *) "style", NULL
38528 };
38529
38530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38531 if (obj0) {
38532 {
38533 arg1 = wxString_in_helper(obj0);
38534 if (arg1 == NULL) SWIG_fail;
38535 temp1 = true;
38536 }
38537 }
38538 if (obj1) {
38539 ecode2 = SWIG_AsVal_long(obj1, &val2);
38540 if (!SWIG_IsOK(ecode2)) {
38541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38542 }
38543 arg2 = static_cast< long >(val2);
38544 }
38545 {
38546 if (!wxPyCheckForApp()) SWIG_fail;
38547 PyThreadState* __tstate = wxPyBeginAllowThreads();
38548 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38549 wxPyEndAllowThreads(__tstate);
38550 if (PyErr_Occurred()) SWIG_fail;
38551 }
38552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38553 {
38554 if (temp1)
38555 delete arg1;
38556 }
38557 return resultobj;
38558 fail:
38559 {
38560 if (temp1)
38561 delete arg1;
38562 }
38563 return NULL;
38564 }
38565
38566
38567 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38568 PyObject *resultobj = 0;
38569 wxMenu *arg1 = (wxMenu *) 0 ;
38570 int arg2 ;
38571 wxString *arg3 = 0 ;
38572 wxString const &arg4_defvalue = wxPyEmptyString ;
38573 wxString *arg4 = (wxString *) &arg4_defvalue ;
38574 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38575 wxMenuItem *result = 0 ;
38576 void *argp1 = 0 ;
38577 int res1 = 0 ;
38578 int val2 ;
38579 int ecode2 = 0 ;
38580 bool temp3 = false ;
38581 bool temp4 = false ;
38582 int val5 ;
38583 int ecode5 = 0 ;
38584 PyObject * obj0 = 0 ;
38585 PyObject * obj1 = 0 ;
38586 PyObject * obj2 = 0 ;
38587 PyObject * obj3 = 0 ;
38588 PyObject * obj4 = 0 ;
38589 char * kwnames[] = {
38590 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38591 };
38592
38593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38595 if (!SWIG_IsOK(res1)) {
38596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38597 }
38598 arg1 = reinterpret_cast< wxMenu * >(argp1);
38599 ecode2 = SWIG_AsVal_int(obj1, &val2);
38600 if (!SWIG_IsOK(ecode2)) {
38601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38602 }
38603 arg2 = static_cast< int >(val2);
38604 {
38605 arg3 = wxString_in_helper(obj2);
38606 if (arg3 == NULL) SWIG_fail;
38607 temp3 = true;
38608 }
38609 if (obj3) {
38610 {
38611 arg4 = wxString_in_helper(obj3);
38612 if (arg4 == NULL) SWIG_fail;
38613 temp4 = true;
38614 }
38615 }
38616 if (obj4) {
38617 ecode5 = SWIG_AsVal_int(obj4, &val5);
38618 if (!SWIG_IsOK(ecode5)) {
38619 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38620 }
38621 arg5 = static_cast< wxItemKind >(val5);
38622 }
38623 {
38624 PyThreadState* __tstate = wxPyBeginAllowThreads();
38625 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38626 wxPyEndAllowThreads(__tstate);
38627 if (PyErr_Occurred()) SWIG_fail;
38628 }
38629 {
38630 resultobj = wxPyMake_wxObject(result, (bool)0);
38631 }
38632 {
38633 if (temp3)
38634 delete arg3;
38635 }
38636 {
38637 if (temp4)
38638 delete arg4;
38639 }
38640 return resultobj;
38641 fail:
38642 {
38643 if (temp3)
38644 delete arg3;
38645 }
38646 {
38647 if (temp4)
38648 delete arg4;
38649 }
38650 return NULL;
38651 }
38652
38653
38654 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38655 PyObject *resultobj = 0;
38656 wxMenu *arg1 = (wxMenu *) 0 ;
38657 wxMenuItem *result = 0 ;
38658 void *argp1 = 0 ;
38659 int res1 = 0 ;
38660 PyObject *swig_obj[1] ;
38661
38662 if (!args) SWIG_fail;
38663 swig_obj[0] = args;
38664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38665 if (!SWIG_IsOK(res1)) {
38666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38667 }
38668 arg1 = reinterpret_cast< wxMenu * >(argp1);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = (wxMenuItem *)(arg1)->AppendSeparator();
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 {
38676 resultobj = wxPyMake_wxObject(result, (bool)0);
38677 }
38678 return resultobj;
38679 fail:
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxMenu *arg1 = (wxMenu *) 0 ;
38687 int arg2 ;
38688 wxString *arg3 = 0 ;
38689 wxString const &arg4_defvalue = wxPyEmptyString ;
38690 wxString *arg4 = (wxString *) &arg4_defvalue ;
38691 wxMenuItem *result = 0 ;
38692 void *argp1 = 0 ;
38693 int res1 = 0 ;
38694 int val2 ;
38695 int ecode2 = 0 ;
38696 bool temp3 = false ;
38697 bool temp4 = false ;
38698 PyObject * obj0 = 0 ;
38699 PyObject * obj1 = 0 ;
38700 PyObject * obj2 = 0 ;
38701 PyObject * obj3 = 0 ;
38702 char * kwnames[] = {
38703 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38704 };
38705
38706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38710 }
38711 arg1 = reinterpret_cast< wxMenu * >(argp1);
38712 ecode2 = SWIG_AsVal_int(obj1, &val2);
38713 if (!SWIG_IsOK(ecode2)) {
38714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38715 }
38716 arg2 = static_cast< int >(val2);
38717 {
38718 arg3 = wxString_in_helper(obj2);
38719 if (arg3 == NULL) SWIG_fail;
38720 temp3 = true;
38721 }
38722 if (obj3) {
38723 {
38724 arg4 = wxString_in_helper(obj3);
38725 if (arg4 == NULL) SWIG_fail;
38726 temp4 = true;
38727 }
38728 }
38729 {
38730 PyThreadState* __tstate = wxPyBeginAllowThreads();
38731 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = wxPyMake_wxObject(result, (bool)0);
38737 }
38738 {
38739 if (temp3)
38740 delete arg3;
38741 }
38742 {
38743 if (temp4)
38744 delete arg4;
38745 }
38746 return resultobj;
38747 fail:
38748 {
38749 if (temp3)
38750 delete arg3;
38751 }
38752 {
38753 if (temp4)
38754 delete arg4;
38755 }
38756 return NULL;
38757 }
38758
38759
38760 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38761 PyObject *resultobj = 0;
38762 wxMenu *arg1 = (wxMenu *) 0 ;
38763 int arg2 ;
38764 wxString *arg3 = 0 ;
38765 wxString const &arg4_defvalue = wxPyEmptyString ;
38766 wxString *arg4 = (wxString *) &arg4_defvalue ;
38767 wxMenuItem *result = 0 ;
38768 void *argp1 = 0 ;
38769 int res1 = 0 ;
38770 int val2 ;
38771 int ecode2 = 0 ;
38772 bool temp3 = false ;
38773 bool temp4 = false ;
38774 PyObject * obj0 = 0 ;
38775 PyObject * obj1 = 0 ;
38776 PyObject * obj2 = 0 ;
38777 PyObject * obj3 = 0 ;
38778 char * kwnames[] = {
38779 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38780 };
38781
38782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38784 if (!SWIG_IsOK(res1)) {
38785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38786 }
38787 arg1 = reinterpret_cast< wxMenu * >(argp1);
38788 ecode2 = SWIG_AsVal_int(obj1, &val2);
38789 if (!SWIG_IsOK(ecode2)) {
38790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38791 }
38792 arg2 = static_cast< int >(val2);
38793 {
38794 arg3 = wxString_in_helper(obj2);
38795 if (arg3 == NULL) SWIG_fail;
38796 temp3 = true;
38797 }
38798 if (obj3) {
38799 {
38800 arg4 = wxString_in_helper(obj3);
38801 if (arg4 == NULL) SWIG_fail;
38802 temp4 = true;
38803 }
38804 }
38805 {
38806 PyThreadState* __tstate = wxPyBeginAllowThreads();
38807 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38808 wxPyEndAllowThreads(__tstate);
38809 if (PyErr_Occurred()) SWIG_fail;
38810 }
38811 {
38812 resultobj = wxPyMake_wxObject(result, (bool)0);
38813 }
38814 {
38815 if (temp3)
38816 delete arg3;
38817 }
38818 {
38819 if (temp4)
38820 delete arg4;
38821 }
38822 return resultobj;
38823 fail:
38824 {
38825 if (temp3)
38826 delete arg3;
38827 }
38828 {
38829 if (temp4)
38830 delete arg4;
38831 }
38832 return NULL;
38833 }
38834
38835
38836 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38837 PyObject *resultobj = 0;
38838 wxMenu *arg1 = (wxMenu *) 0 ;
38839 int arg2 ;
38840 wxString *arg3 = 0 ;
38841 wxMenu *arg4 = (wxMenu *) 0 ;
38842 wxString const &arg5_defvalue = wxPyEmptyString ;
38843 wxString *arg5 = (wxString *) &arg5_defvalue ;
38844 wxMenuItem *result = 0 ;
38845 void *argp1 = 0 ;
38846 int res1 = 0 ;
38847 int val2 ;
38848 int ecode2 = 0 ;
38849 bool temp3 = false ;
38850 void *argp4 = 0 ;
38851 int res4 = 0 ;
38852 bool temp5 = false ;
38853 PyObject * obj0 = 0 ;
38854 PyObject * obj1 = 0 ;
38855 PyObject * obj2 = 0 ;
38856 PyObject * obj3 = 0 ;
38857 PyObject * obj4 = 0 ;
38858 char * kwnames[] = {
38859 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38860 };
38861
38862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38864 if (!SWIG_IsOK(res1)) {
38865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38866 }
38867 arg1 = reinterpret_cast< wxMenu * >(argp1);
38868 ecode2 = SWIG_AsVal_int(obj1, &val2);
38869 if (!SWIG_IsOK(ecode2)) {
38870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38871 }
38872 arg2 = static_cast< int >(val2);
38873 {
38874 arg3 = wxString_in_helper(obj2);
38875 if (arg3 == NULL) SWIG_fail;
38876 temp3 = true;
38877 }
38878 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38879 if (!SWIG_IsOK(res4)) {
38880 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38881 }
38882 arg4 = reinterpret_cast< wxMenu * >(argp4);
38883 if (obj4) {
38884 {
38885 arg5 = wxString_in_helper(obj4);
38886 if (arg5 == NULL) SWIG_fail;
38887 temp5 = true;
38888 }
38889 }
38890 {
38891 PyThreadState* __tstate = wxPyBeginAllowThreads();
38892 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38893 wxPyEndAllowThreads(__tstate);
38894 if (PyErr_Occurred()) SWIG_fail;
38895 }
38896 {
38897 resultobj = wxPyMake_wxObject(result, (bool)0);
38898 }
38899 {
38900 if (temp3)
38901 delete arg3;
38902 }
38903 {
38904 if (temp5)
38905 delete arg5;
38906 }
38907 return resultobj;
38908 fail:
38909 {
38910 if (temp3)
38911 delete arg3;
38912 }
38913 {
38914 if (temp5)
38915 delete arg5;
38916 }
38917 return NULL;
38918 }
38919
38920
38921 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38922 PyObject *resultobj = 0;
38923 wxMenu *arg1 = (wxMenu *) 0 ;
38924 wxMenu *arg2 = (wxMenu *) 0 ;
38925 wxString *arg3 = 0 ;
38926 wxString const &arg4_defvalue = wxPyEmptyString ;
38927 wxString *arg4 = (wxString *) &arg4_defvalue ;
38928 wxMenuItem *result = 0 ;
38929 void *argp1 = 0 ;
38930 int res1 = 0 ;
38931 void *argp2 = 0 ;
38932 int res2 = 0 ;
38933 bool temp3 = false ;
38934 bool temp4 = false ;
38935 PyObject * obj0 = 0 ;
38936 PyObject * obj1 = 0 ;
38937 PyObject * obj2 = 0 ;
38938 PyObject * obj3 = 0 ;
38939 char * kwnames[] = {
38940 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38941 };
38942
38943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38945 if (!SWIG_IsOK(res1)) {
38946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38947 }
38948 arg1 = reinterpret_cast< wxMenu * >(argp1);
38949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38950 if (!SWIG_IsOK(res2)) {
38951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38952 }
38953 arg2 = reinterpret_cast< wxMenu * >(argp2);
38954 {
38955 arg3 = wxString_in_helper(obj2);
38956 if (arg3 == NULL) SWIG_fail;
38957 temp3 = true;
38958 }
38959 if (obj3) {
38960 {
38961 arg4 = wxString_in_helper(obj3);
38962 if (arg4 == NULL) SWIG_fail;
38963 temp4 = true;
38964 }
38965 }
38966 {
38967 PyThreadState* __tstate = wxPyBeginAllowThreads();
38968 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38969 wxPyEndAllowThreads(__tstate);
38970 if (PyErr_Occurred()) SWIG_fail;
38971 }
38972 {
38973 resultobj = wxPyMake_wxObject(result, (bool)0);
38974 }
38975 {
38976 if (temp3)
38977 delete arg3;
38978 }
38979 {
38980 if (temp4)
38981 delete arg4;
38982 }
38983 return resultobj;
38984 fail:
38985 {
38986 if (temp3)
38987 delete arg3;
38988 }
38989 {
38990 if (temp4)
38991 delete arg4;
38992 }
38993 return NULL;
38994 }
38995
38996
38997 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38998 PyObject *resultobj = 0;
38999 wxMenu *arg1 = (wxMenu *) 0 ;
39000 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39001 wxMenuItem *result = 0 ;
39002 void *argp1 = 0 ;
39003 int res1 = 0 ;
39004 int res2 = 0 ;
39005 PyObject * obj0 = 0 ;
39006 PyObject * obj1 = 0 ;
39007 char * kwnames[] = {
39008 (char *) "self",(char *) "item", NULL
39009 };
39010
39011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39013 if (!SWIG_IsOK(res1)) {
39014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39015 }
39016 arg1 = reinterpret_cast< wxMenu * >(argp1);
39017 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39018 if (!SWIG_IsOK(res2)) {
39019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39020 }
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 result = (wxMenuItem *)(arg1)->Append(arg2);
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 {
39028 resultobj = wxPyMake_wxObject(result, (bool)0);
39029 }
39030 return resultobj;
39031 fail:
39032 return NULL;
39033 }
39034
39035
39036 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39037 PyObject *resultobj = 0;
39038 wxMenu *arg1 = (wxMenu *) 0 ;
39039 size_t arg2 ;
39040 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39041 wxMenuItem *result = 0 ;
39042 void *argp1 = 0 ;
39043 int res1 = 0 ;
39044 size_t val2 ;
39045 int ecode2 = 0 ;
39046 int res3 = 0 ;
39047 PyObject * obj0 = 0 ;
39048 PyObject * obj1 = 0 ;
39049 PyObject * obj2 = 0 ;
39050 char * kwnames[] = {
39051 (char *) "self",(char *) "pos",(char *) "item", NULL
39052 };
39053
39054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39056 if (!SWIG_IsOK(res1)) {
39057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39058 }
39059 arg1 = reinterpret_cast< wxMenu * >(argp1);
39060 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39061 if (!SWIG_IsOK(ecode2)) {
39062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39063 }
39064 arg2 = static_cast< size_t >(val2);
39065 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39066 if (!SWIG_IsOK(res3)) {
39067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39068 }
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39072 wxPyEndAllowThreads(__tstate);
39073 if (PyErr_Occurred()) SWIG_fail;
39074 }
39075 {
39076 resultobj = wxPyMake_wxObject(result, (bool)0);
39077 }
39078 return resultobj;
39079 fail:
39080 return NULL;
39081 }
39082
39083
39084 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39085 PyObject *resultobj = 0;
39086 wxMenu *arg1 = (wxMenu *) 0 ;
39087 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39088 wxMenuItem *result = 0 ;
39089 void *argp1 = 0 ;
39090 int res1 = 0 ;
39091 int res2 = 0 ;
39092 PyObject * obj0 = 0 ;
39093 PyObject * obj1 = 0 ;
39094 char * kwnames[] = {
39095 (char *) "self",(char *) "item", NULL
39096 };
39097
39098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39100 if (!SWIG_IsOK(res1)) {
39101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39102 }
39103 arg1 = reinterpret_cast< wxMenu * >(argp1);
39104 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39105 if (!SWIG_IsOK(res2)) {
39106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39107 }
39108 {
39109 PyThreadState* __tstate = wxPyBeginAllowThreads();
39110 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39111 wxPyEndAllowThreads(__tstate);
39112 if (PyErr_Occurred()) SWIG_fail;
39113 }
39114 {
39115 resultobj = wxPyMake_wxObject(result, (bool)0);
39116 }
39117 return resultobj;
39118 fail:
39119 return NULL;
39120 }
39121
39122
39123 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39124 PyObject *resultobj = 0;
39125 wxMenu *arg1 = (wxMenu *) 0 ;
39126 void *argp1 = 0 ;
39127 int res1 = 0 ;
39128 PyObject *swig_obj[1] ;
39129
39130 if (!args) SWIG_fail;
39131 swig_obj[0] = args;
39132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39133 if (!SWIG_IsOK(res1)) {
39134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39135 }
39136 arg1 = reinterpret_cast< wxMenu * >(argp1);
39137 {
39138 PyThreadState* __tstate = wxPyBeginAllowThreads();
39139 (arg1)->Break();
39140 wxPyEndAllowThreads(__tstate);
39141 if (PyErr_Occurred()) SWIG_fail;
39142 }
39143 resultobj = SWIG_Py_Void();
39144 return resultobj;
39145 fail:
39146 return NULL;
39147 }
39148
39149
39150 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39151 PyObject *resultobj = 0;
39152 wxMenu *arg1 = (wxMenu *) 0 ;
39153 size_t arg2 ;
39154 int arg3 ;
39155 wxString *arg4 = 0 ;
39156 wxString const &arg5_defvalue = wxPyEmptyString ;
39157 wxString *arg5 = (wxString *) &arg5_defvalue ;
39158 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39159 wxMenuItem *result = 0 ;
39160 void *argp1 = 0 ;
39161 int res1 = 0 ;
39162 size_t val2 ;
39163 int ecode2 = 0 ;
39164 int val3 ;
39165 int ecode3 = 0 ;
39166 bool temp4 = false ;
39167 bool temp5 = false ;
39168 int val6 ;
39169 int ecode6 = 0 ;
39170 PyObject * obj0 = 0 ;
39171 PyObject * obj1 = 0 ;
39172 PyObject * obj2 = 0 ;
39173 PyObject * obj3 = 0 ;
39174 PyObject * obj4 = 0 ;
39175 PyObject * obj5 = 0 ;
39176 char * kwnames[] = {
39177 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39178 };
39179
39180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39182 if (!SWIG_IsOK(res1)) {
39183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39184 }
39185 arg1 = reinterpret_cast< wxMenu * >(argp1);
39186 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39187 if (!SWIG_IsOK(ecode2)) {
39188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39189 }
39190 arg2 = static_cast< size_t >(val2);
39191 ecode3 = SWIG_AsVal_int(obj2, &val3);
39192 if (!SWIG_IsOK(ecode3)) {
39193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39194 }
39195 arg3 = static_cast< int >(val3);
39196 {
39197 arg4 = wxString_in_helper(obj3);
39198 if (arg4 == NULL) SWIG_fail;
39199 temp4 = true;
39200 }
39201 if (obj4) {
39202 {
39203 arg5 = wxString_in_helper(obj4);
39204 if (arg5 == NULL) SWIG_fail;
39205 temp5 = true;
39206 }
39207 }
39208 if (obj5) {
39209 ecode6 = SWIG_AsVal_int(obj5, &val6);
39210 if (!SWIG_IsOK(ecode6)) {
39211 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39212 }
39213 arg6 = static_cast< wxItemKind >(val6);
39214 }
39215 {
39216 PyThreadState* __tstate = wxPyBeginAllowThreads();
39217 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39218 wxPyEndAllowThreads(__tstate);
39219 if (PyErr_Occurred()) SWIG_fail;
39220 }
39221 {
39222 resultobj = wxPyMake_wxObject(result, (bool)0);
39223 }
39224 {
39225 if (temp4)
39226 delete arg4;
39227 }
39228 {
39229 if (temp5)
39230 delete arg5;
39231 }
39232 return resultobj;
39233 fail:
39234 {
39235 if (temp4)
39236 delete arg4;
39237 }
39238 {
39239 if (temp5)
39240 delete arg5;
39241 }
39242 return NULL;
39243 }
39244
39245
39246 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39247 PyObject *resultobj = 0;
39248 wxMenu *arg1 = (wxMenu *) 0 ;
39249 size_t arg2 ;
39250 wxMenuItem *result = 0 ;
39251 void *argp1 = 0 ;
39252 int res1 = 0 ;
39253 size_t val2 ;
39254 int ecode2 = 0 ;
39255 PyObject * obj0 = 0 ;
39256 PyObject * obj1 = 0 ;
39257 char * kwnames[] = {
39258 (char *) "self",(char *) "pos", NULL
39259 };
39260
39261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39263 if (!SWIG_IsOK(res1)) {
39264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39265 }
39266 arg1 = reinterpret_cast< wxMenu * >(argp1);
39267 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39268 if (!SWIG_IsOK(ecode2)) {
39269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39270 }
39271 arg2 = static_cast< size_t >(val2);
39272 {
39273 PyThreadState* __tstate = wxPyBeginAllowThreads();
39274 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39275 wxPyEndAllowThreads(__tstate);
39276 if (PyErr_Occurred()) SWIG_fail;
39277 }
39278 {
39279 resultobj = wxPyMake_wxObject(result, (bool)0);
39280 }
39281 return resultobj;
39282 fail:
39283 return NULL;
39284 }
39285
39286
39287 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39288 PyObject *resultobj = 0;
39289 wxMenu *arg1 = (wxMenu *) 0 ;
39290 size_t arg2 ;
39291 int arg3 ;
39292 wxString *arg4 = 0 ;
39293 wxString const &arg5_defvalue = wxPyEmptyString ;
39294 wxString *arg5 = (wxString *) &arg5_defvalue ;
39295 wxMenuItem *result = 0 ;
39296 void *argp1 = 0 ;
39297 int res1 = 0 ;
39298 size_t val2 ;
39299 int ecode2 = 0 ;
39300 int val3 ;
39301 int ecode3 = 0 ;
39302 bool temp4 = false ;
39303 bool temp5 = false ;
39304 PyObject * obj0 = 0 ;
39305 PyObject * obj1 = 0 ;
39306 PyObject * obj2 = 0 ;
39307 PyObject * obj3 = 0 ;
39308 PyObject * obj4 = 0 ;
39309 char * kwnames[] = {
39310 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39311 };
39312
39313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39315 if (!SWIG_IsOK(res1)) {
39316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39317 }
39318 arg1 = reinterpret_cast< wxMenu * >(argp1);
39319 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39320 if (!SWIG_IsOK(ecode2)) {
39321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39322 }
39323 arg2 = static_cast< size_t >(val2);
39324 ecode3 = SWIG_AsVal_int(obj2, &val3);
39325 if (!SWIG_IsOK(ecode3)) {
39326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39327 }
39328 arg3 = static_cast< int >(val3);
39329 {
39330 arg4 = wxString_in_helper(obj3);
39331 if (arg4 == NULL) SWIG_fail;
39332 temp4 = true;
39333 }
39334 if (obj4) {
39335 {
39336 arg5 = wxString_in_helper(obj4);
39337 if (arg5 == NULL) SWIG_fail;
39338 temp5 = true;
39339 }
39340 }
39341 {
39342 PyThreadState* __tstate = wxPyBeginAllowThreads();
39343 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39344 wxPyEndAllowThreads(__tstate);
39345 if (PyErr_Occurred()) SWIG_fail;
39346 }
39347 {
39348 resultobj = wxPyMake_wxObject(result, (bool)0);
39349 }
39350 {
39351 if (temp4)
39352 delete arg4;
39353 }
39354 {
39355 if (temp5)
39356 delete arg5;
39357 }
39358 return resultobj;
39359 fail:
39360 {
39361 if (temp4)
39362 delete arg4;
39363 }
39364 {
39365 if (temp5)
39366 delete arg5;
39367 }
39368 return NULL;
39369 }
39370
39371
39372 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39373 PyObject *resultobj = 0;
39374 wxMenu *arg1 = (wxMenu *) 0 ;
39375 size_t arg2 ;
39376 int arg3 ;
39377 wxString *arg4 = 0 ;
39378 wxString const &arg5_defvalue = wxPyEmptyString ;
39379 wxString *arg5 = (wxString *) &arg5_defvalue ;
39380 wxMenuItem *result = 0 ;
39381 void *argp1 = 0 ;
39382 int res1 = 0 ;
39383 size_t val2 ;
39384 int ecode2 = 0 ;
39385 int val3 ;
39386 int ecode3 = 0 ;
39387 bool temp4 = false ;
39388 bool temp5 = false ;
39389 PyObject * obj0 = 0 ;
39390 PyObject * obj1 = 0 ;
39391 PyObject * obj2 = 0 ;
39392 PyObject * obj3 = 0 ;
39393 PyObject * obj4 = 0 ;
39394 char * kwnames[] = {
39395 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39396 };
39397
39398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39400 if (!SWIG_IsOK(res1)) {
39401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39402 }
39403 arg1 = reinterpret_cast< wxMenu * >(argp1);
39404 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39405 if (!SWIG_IsOK(ecode2)) {
39406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39407 }
39408 arg2 = static_cast< size_t >(val2);
39409 ecode3 = SWIG_AsVal_int(obj2, &val3);
39410 if (!SWIG_IsOK(ecode3)) {
39411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39412 }
39413 arg3 = static_cast< int >(val3);
39414 {
39415 arg4 = wxString_in_helper(obj3);
39416 if (arg4 == NULL) SWIG_fail;
39417 temp4 = true;
39418 }
39419 if (obj4) {
39420 {
39421 arg5 = wxString_in_helper(obj4);
39422 if (arg5 == NULL) SWIG_fail;
39423 temp5 = true;
39424 }
39425 }
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39429 wxPyEndAllowThreads(__tstate);
39430 if (PyErr_Occurred()) SWIG_fail;
39431 }
39432 {
39433 resultobj = wxPyMake_wxObject(result, (bool)0);
39434 }
39435 {
39436 if (temp4)
39437 delete arg4;
39438 }
39439 {
39440 if (temp5)
39441 delete arg5;
39442 }
39443 return resultobj;
39444 fail:
39445 {
39446 if (temp4)
39447 delete arg4;
39448 }
39449 {
39450 if (temp5)
39451 delete arg5;
39452 }
39453 return NULL;
39454 }
39455
39456
39457 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39458 PyObject *resultobj = 0;
39459 wxMenu *arg1 = (wxMenu *) 0 ;
39460 size_t arg2 ;
39461 int arg3 ;
39462 wxString *arg4 = 0 ;
39463 wxMenu *arg5 = (wxMenu *) 0 ;
39464 wxString const &arg6_defvalue = wxPyEmptyString ;
39465 wxString *arg6 = (wxString *) &arg6_defvalue ;
39466 wxMenuItem *result = 0 ;
39467 void *argp1 = 0 ;
39468 int res1 = 0 ;
39469 size_t val2 ;
39470 int ecode2 = 0 ;
39471 int val3 ;
39472 int ecode3 = 0 ;
39473 bool temp4 = false ;
39474 void *argp5 = 0 ;
39475 int res5 = 0 ;
39476 bool temp6 = false ;
39477 PyObject * obj0 = 0 ;
39478 PyObject * obj1 = 0 ;
39479 PyObject * obj2 = 0 ;
39480 PyObject * obj3 = 0 ;
39481 PyObject * obj4 = 0 ;
39482 PyObject * obj5 = 0 ;
39483 char * kwnames[] = {
39484 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39485 };
39486
39487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39489 if (!SWIG_IsOK(res1)) {
39490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39491 }
39492 arg1 = reinterpret_cast< wxMenu * >(argp1);
39493 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39494 if (!SWIG_IsOK(ecode2)) {
39495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39496 }
39497 arg2 = static_cast< size_t >(val2);
39498 ecode3 = SWIG_AsVal_int(obj2, &val3);
39499 if (!SWIG_IsOK(ecode3)) {
39500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39501 }
39502 arg3 = static_cast< int >(val3);
39503 {
39504 arg4 = wxString_in_helper(obj3);
39505 if (arg4 == NULL) SWIG_fail;
39506 temp4 = true;
39507 }
39508 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39509 if (!SWIG_IsOK(res5)) {
39510 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39511 }
39512 arg5 = reinterpret_cast< wxMenu * >(argp5);
39513 if (obj5) {
39514 {
39515 arg6 = wxString_in_helper(obj5);
39516 if (arg6 == NULL) SWIG_fail;
39517 temp6 = true;
39518 }
39519 }
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39523 wxPyEndAllowThreads(__tstate);
39524 if (PyErr_Occurred()) SWIG_fail;
39525 }
39526 {
39527 resultobj = wxPyMake_wxObject(result, (bool)0);
39528 }
39529 {
39530 if (temp4)
39531 delete arg4;
39532 }
39533 {
39534 if (temp6)
39535 delete arg6;
39536 }
39537 return resultobj;
39538 fail:
39539 {
39540 if (temp4)
39541 delete arg4;
39542 }
39543 {
39544 if (temp6)
39545 delete arg6;
39546 }
39547 return NULL;
39548 }
39549
39550
39551 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39552 PyObject *resultobj = 0;
39553 wxMenu *arg1 = (wxMenu *) 0 ;
39554 int arg2 ;
39555 wxString *arg3 = 0 ;
39556 wxString const &arg4_defvalue = wxPyEmptyString ;
39557 wxString *arg4 = (wxString *) &arg4_defvalue ;
39558 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39559 wxMenuItem *result = 0 ;
39560 void *argp1 = 0 ;
39561 int res1 = 0 ;
39562 int val2 ;
39563 int ecode2 = 0 ;
39564 bool temp3 = false ;
39565 bool temp4 = false ;
39566 int val5 ;
39567 int ecode5 = 0 ;
39568 PyObject * obj0 = 0 ;
39569 PyObject * obj1 = 0 ;
39570 PyObject * obj2 = 0 ;
39571 PyObject * obj3 = 0 ;
39572 PyObject * obj4 = 0 ;
39573 char * kwnames[] = {
39574 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39575 };
39576
39577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39579 if (!SWIG_IsOK(res1)) {
39580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39581 }
39582 arg1 = reinterpret_cast< wxMenu * >(argp1);
39583 ecode2 = SWIG_AsVal_int(obj1, &val2);
39584 if (!SWIG_IsOK(ecode2)) {
39585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39586 }
39587 arg2 = static_cast< int >(val2);
39588 {
39589 arg3 = wxString_in_helper(obj2);
39590 if (arg3 == NULL) SWIG_fail;
39591 temp3 = true;
39592 }
39593 if (obj3) {
39594 {
39595 arg4 = wxString_in_helper(obj3);
39596 if (arg4 == NULL) SWIG_fail;
39597 temp4 = true;
39598 }
39599 }
39600 if (obj4) {
39601 ecode5 = SWIG_AsVal_int(obj4, &val5);
39602 if (!SWIG_IsOK(ecode5)) {
39603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39604 }
39605 arg5 = static_cast< wxItemKind >(val5);
39606 }
39607 {
39608 PyThreadState* __tstate = wxPyBeginAllowThreads();
39609 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39610 wxPyEndAllowThreads(__tstate);
39611 if (PyErr_Occurred()) SWIG_fail;
39612 }
39613 {
39614 resultobj = wxPyMake_wxObject(result, (bool)0);
39615 }
39616 {
39617 if (temp3)
39618 delete arg3;
39619 }
39620 {
39621 if (temp4)
39622 delete arg4;
39623 }
39624 return resultobj;
39625 fail:
39626 {
39627 if (temp3)
39628 delete arg3;
39629 }
39630 {
39631 if (temp4)
39632 delete arg4;
39633 }
39634 return NULL;
39635 }
39636
39637
39638 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39639 PyObject *resultobj = 0;
39640 wxMenu *arg1 = (wxMenu *) 0 ;
39641 wxMenuItem *result = 0 ;
39642 void *argp1 = 0 ;
39643 int res1 = 0 ;
39644 PyObject *swig_obj[1] ;
39645
39646 if (!args) SWIG_fail;
39647 swig_obj[0] = args;
39648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39649 if (!SWIG_IsOK(res1)) {
39650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39651 }
39652 arg1 = reinterpret_cast< wxMenu * >(argp1);
39653 {
39654 PyThreadState* __tstate = wxPyBeginAllowThreads();
39655 result = (wxMenuItem *)(arg1)->PrependSeparator();
39656 wxPyEndAllowThreads(__tstate);
39657 if (PyErr_Occurred()) SWIG_fail;
39658 }
39659 {
39660 resultobj = wxPyMake_wxObject(result, (bool)0);
39661 }
39662 return resultobj;
39663 fail:
39664 return NULL;
39665 }
39666
39667
39668 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39669 PyObject *resultobj = 0;
39670 wxMenu *arg1 = (wxMenu *) 0 ;
39671 int arg2 ;
39672 wxString *arg3 = 0 ;
39673 wxString const &arg4_defvalue = wxPyEmptyString ;
39674 wxString *arg4 = (wxString *) &arg4_defvalue ;
39675 wxMenuItem *result = 0 ;
39676 void *argp1 = 0 ;
39677 int res1 = 0 ;
39678 int val2 ;
39679 int ecode2 = 0 ;
39680 bool temp3 = false ;
39681 bool temp4 = false ;
39682 PyObject * obj0 = 0 ;
39683 PyObject * obj1 = 0 ;
39684 PyObject * obj2 = 0 ;
39685 PyObject * obj3 = 0 ;
39686 char * kwnames[] = {
39687 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39688 };
39689
39690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39692 if (!SWIG_IsOK(res1)) {
39693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39694 }
39695 arg1 = reinterpret_cast< wxMenu * >(argp1);
39696 ecode2 = SWIG_AsVal_int(obj1, &val2);
39697 if (!SWIG_IsOK(ecode2)) {
39698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39699 }
39700 arg2 = static_cast< int >(val2);
39701 {
39702 arg3 = wxString_in_helper(obj2);
39703 if (arg3 == NULL) SWIG_fail;
39704 temp3 = true;
39705 }
39706 if (obj3) {
39707 {
39708 arg4 = wxString_in_helper(obj3);
39709 if (arg4 == NULL) SWIG_fail;
39710 temp4 = true;
39711 }
39712 }
39713 {
39714 PyThreadState* __tstate = wxPyBeginAllowThreads();
39715 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39716 wxPyEndAllowThreads(__tstate);
39717 if (PyErr_Occurred()) SWIG_fail;
39718 }
39719 {
39720 resultobj = wxPyMake_wxObject(result, (bool)0);
39721 }
39722 {
39723 if (temp3)
39724 delete arg3;
39725 }
39726 {
39727 if (temp4)
39728 delete arg4;
39729 }
39730 return resultobj;
39731 fail:
39732 {
39733 if (temp3)
39734 delete arg3;
39735 }
39736 {
39737 if (temp4)
39738 delete arg4;
39739 }
39740 return NULL;
39741 }
39742
39743
39744 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39745 PyObject *resultobj = 0;
39746 wxMenu *arg1 = (wxMenu *) 0 ;
39747 int arg2 ;
39748 wxString *arg3 = 0 ;
39749 wxString const &arg4_defvalue = wxPyEmptyString ;
39750 wxString *arg4 = (wxString *) &arg4_defvalue ;
39751 wxMenuItem *result = 0 ;
39752 void *argp1 = 0 ;
39753 int res1 = 0 ;
39754 int val2 ;
39755 int ecode2 = 0 ;
39756 bool temp3 = false ;
39757 bool temp4 = false ;
39758 PyObject * obj0 = 0 ;
39759 PyObject * obj1 = 0 ;
39760 PyObject * obj2 = 0 ;
39761 PyObject * obj3 = 0 ;
39762 char * kwnames[] = {
39763 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39764 };
39765
39766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39768 if (!SWIG_IsOK(res1)) {
39769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39770 }
39771 arg1 = reinterpret_cast< wxMenu * >(argp1);
39772 ecode2 = SWIG_AsVal_int(obj1, &val2);
39773 if (!SWIG_IsOK(ecode2)) {
39774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39775 }
39776 arg2 = static_cast< int >(val2);
39777 {
39778 arg3 = wxString_in_helper(obj2);
39779 if (arg3 == NULL) SWIG_fail;
39780 temp3 = true;
39781 }
39782 if (obj3) {
39783 {
39784 arg4 = wxString_in_helper(obj3);
39785 if (arg4 == NULL) SWIG_fail;
39786 temp4 = true;
39787 }
39788 }
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 {
39796 resultobj = wxPyMake_wxObject(result, (bool)0);
39797 }
39798 {
39799 if (temp3)
39800 delete arg3;
39801 }
39802 {
39803 if (temp4)
39804 delete arg4;
39805 }
39806 return resultobj;
39807 fail:
39808 {
39809 if (temp3)
39810 delete arg3;
39811 }
39812 {
39813 if (temp4)
39814 delete arg4;
39815 }
39816 return NULL;
39817 }
39818
39819
39820 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39821 PyObject *resultobj = 0;
39822 wxMenu *arg1 = (wxMenu *) 0 ;
39823 int arg2 ;
39824 wxString *arg3 = 0 ;
39825 wxMenu *arg4 = (wxMenu *) 0 ;
39826 wxString const &arg5_defvalue = wxPyEmptyString ;
39827 wxString *arg5 = (wxString *) &arg5_defvalue ;
39828 wxMenuItem *result = 0 ;
39829 void *argp1 = 0 ;
39830 int res1 = 0 ;
39831 int val2 ;
39832 int ecode2 = 0 ;
39833 bool temp3 = false ;
39834 void *argp4 = 0 ;
39835 int res4 = 0 ;
39836 bool temp5 = false ;
39837 PyObject * obj0 = 0 ;
39838 PyObject * obj1 = 0 ;
39839 PyObject * obj2 = 0 ;
39840 PyObject * obj3 = 0 ;
39841 PyObject * obj4 = 0 ;
39842 char * kwnames[] = {
39843 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39844 };
39845
39846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39848 if (!SWIG_IsOK(res1)) {
39849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39850 }
39851 arg1 = reinterpret_cast< wxMenu * >(argp1);
39852 ecode2 = SWIG_AsVal_int(obj1, &val2);
39853 if (!SWIG_IsOK(ecode2)) {
39854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39855 }
39856 arg2 = static_cast< int >(val2);
39857 {
39858 arg3 = wxString_in_helper(obj2);
39859 if (arg3 == NULL) SWIG_fail;
39860 temp3 = true;
39861 }
39862 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39863 if (!SWIG_IsOK(res4)) {
39864 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39865 }
39866 arg4 = reinterpret_cast< wxMenu * >(argp4);
39867 if (obj4) {
39868 {
39869 arg5 = wxString_in_helper(obj4);
39870 if (arg5 == NULL) SWIG_fail;
39871 temp5 = true;
39872 }
39873 }
39874 {
39875 PyThreadState* __tstate = wxPyBeginAllowThreads();
39876 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39877 wxPyEndAllowThreads(__tstate);
39878 if (PyErr_Occurred()) SWIG_fail;
39879 }
39880 {
39881 resultobj = wxPyMake_wxObject(result, (bool)0);
39882 }
39883 {
39884 if (temp3)
39885 delete arg3;
39886 }
39887 {
39888 if (temp5)
39889 delete arg5;
39890 }
39891 return resultobj;
39892 fail:
39893 {
39894 if (temp3)
39895 delete arg3;
39896 }
39897 {
39898 if (temp5)
39899 delete arg5;
39900 }
39901 return NULL;
39902 }
39903
39904
39905 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39906 PyObject *resultobj = 0;
39907 wxMenu *arg1 = (wxMenu *) 0 ;
39908 int arg2 ;
39909 wxMenuItem *result = 0 ;
39910 void *argp1 = 0 ;
39911 int res1 = 0 ;
39912 int val2 ;
39913 int ecode2 = 0 ;
39914 PyObject * obj0 = 0 ;
39915 PyObject * obj1 = 0 ;
39916 char * kwnames[] = {
39917 (char *) "self",(char *) "id", NULL
39918 };
39919
39920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39922 if (!SWIG_IsOK(res1)) {
39923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39924 }
39925 arg1 = reinterpret_cast< wxMenu * >(argp1);
39926 ecode2 = SWIG_AsVal_int(obj1, &val2);
39927 if (!SWIG_IsOK(ecode2)) {
39928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39929 }
39930 arg2 = static_cast< int >(val2);
39931 {
39932 PyThreadState* __tstate = wxPyBeginAllowThreads();
39933 result = (wxMenuItem *)(arg1)->Remove(arg2);
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 {
39938 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39939 }
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj = 0;
39948 wxMenu *arg1 = (wxMenu *) 0 ;
39949 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39950 wxMenuItem *result = 0 ;
39951 void *argp1 = 0 ;
39952 int res1 = 0 ;
39953 void *argp2 = 0 ;
39954 int res2 = 0 ;
39955 PyObject * obj0 = 0 ;
39956 PyObject * obj1 = 0 ;
39957 char * kwnames[] = {
39958 (char *) "self",(char *) "item", NULL
39959 };
39960
39961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39963 if (!SWIG_IsOK(res1)) {
39964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39965 }
39966 arg1 = reinterpret_cast< wxMenu * >(argp1);
39967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39968 if (!SWIG_IsOK(res2)) {
39969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39970 }
39971 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39972 {
39973 PyThreadState* __tstate = wxPyBeginAllowThreads();
39974 result = (wxMenuItem *)(arg1)->Remove(arg2);
39975 wxPyEndAllowThreads(__tstate);
39976 if (PyErr_Occurred()) SWIG_fail;
39977 }
39978 {
39979 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39980 }
39981 return resultobj;
39982 fail:
39983 return NULL;
39984 }
39985
39986
39987 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39988 PyObject *resultobj = 0;
39989 wxMenu *arg1 = (wxMenu *) 0 ;
39990 int arg2 ;
39991 bool result;
39992 void *argp1 = 0 ;
39993 int res1 = 0 ;
39994 int val2 ;
39995 int ecode2 = 0 ;
39996 PyObject * obj0 = 0 ;
39997 PyObject * obj1 = 0 ;
39998 char * kwnames[] = {
39999 (char *) "self",(char *) "id", NULL
40000 };
40001
40002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40004 if (!SWIG_IsOK(res1)) {
40005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40006 }
40007 arg1 = reinterpret_cast< wxMenu * >(argp1);
40008 ecode2 = SWIG_AsVal_int(obj1, &val2);
40009 if (!SWIG_IsOK(ecode2)) {
40010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40011 }
40012 arg2 = static_cast< int >(val2);
40013 {
40014 PyThreadState* __tstate = wxPyBeginAllowThreads();
40015 result = (bool)(arg1)->Delete(arg2);
40016 wxPyEndAllowThreads(__tstate);
40017 if (PyErr_Occurred()) SWIG_fail;
40018 }
40019 {
40020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40021 }
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj = 0;
40030 wxMenu *arg1 = (wxMenu *) 0 ;
40031 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40032 bool result;
40033 void *argp1 = 0 ;
40034 int res1 = 0 ;
40035 void *argp2 = 0 ;
40036 int res2 = 0 ;
40037 PyObject * obj0 = 0 ;
40038 PyObject * obj1 = 0 ;
40039 char * kwnames[] = {
40040 (char *) "self",(char *) "item", NULL
40041 };
40042
40043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40045 if (!SWIG_IsOK(res1)) {
40046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40047 }
40048 arg1 = reinterpret_cast< wxMenu * >(argp1);
40049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40050 if (!SWIG_IsOK(res2)) {
40051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40052 }
40053 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 result = (bool)(arg1)->Delete(arg2);
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 {
40061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40062 }
40063 return resultobj;
40064 fail:
40065 return NULL;
40066 }
40067
40068
40069 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40070 PyObject *resultobj = 0;
40071 wxMenu *arg1 = (wxMenu *) 0 ;
40072 void *argp1 = 0 ;
40073 int res1 = 0 ;
40074 PyObject *swig_obj[1] ;
40075
40076 if (!args) SWIG_fail;
40077 swig_obj[0] = args;
40078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40079 if (!SWIG_IsOK(res1)) {
40080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40081 }
40082 arg1 = reinterpret_cast< wxMenu * >(argp1);
40083 {
40084 PyThreadState* __tstate = wxPyBeginAllowThreads();
40085 wxMenu_Destroy(arg1);
40086 wxPyEndAllowThreads(__tstate);
40087 if (PyErr_Occurred()) SWIG_fail;
40088 }
40089 resultobj = SWIG_Py_Void();
40090 return resultobj;
40091 fail:
40092 return NULL;
40093 }
40094
40095
40096 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40097 PyObject *resultobj = 0;
40098 wxMenu *arg1 = (wxMenu *) 0 ;
40099 int arg2 ;
40100 bool result;
40101 void *argp1 = 0 ;
40102 int res1 = 0 ;
40103 int val2 ;
40104 int ecode2 = 0 ;
40105 PyObject * obj0 = 0 ;
40106 PyObject * obj1 = 0 ;
40107 char * kwnames[] = {
40108 (char *) "self",(char *) "id", NULL
40109 };
40110
40111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40113 if (!SWIG_IsOK(res1)) {
40114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40115 }
40116 arg1 = reinterpret_cast< wxMenu * >(argp1);
40117 ecode2 = SWIG_AsVal_int(obj1, &val2);
40118 if (!SWIG_IsOK(ecode2)) {
40119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40120 }
40121 arg2 = static_cast< int >(val2);
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 result = (bool)(arg1)->Destroy(arg2);
40125 wxPyEndAllowThreads(__tstate);
40126 if (PyErr_Occurred()) SWIG_fail;
40127 }
40128 {
40129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40130 }
40131 return resultobj;
40132 fail:
40133 return NULL;
40134 }
40135
40136
40137 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40138 PyObject *resultobj = 0;
40139 wxMenu *arg1 = (wxMenu *) 0 ;
40140 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40141 bool result;
40142 void *argp1 = 0 ;
40143 int res1 = 0 ;
40144 void *argp2 = 0 ;
40145 int res2 = 0 ;
40146 PyObject * obj0 = 0 ;
40147 PyObject * obj1 = 0 ;
40148 char * kwnames[] = {
40149 (char *) "self",(char *) "item", NULL
40150 };
40151
40152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40154 if (!SWIG_IsOK(res1)) {
40155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40156 }
40157 arg1 = reinterpret_cast< wxMenu * >(argp1);
40158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40159 if (!SWIG_IsOK(res2)) {
40160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40161 }
40162 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 result = (bool)(arg1)->Destroy(arg2);
40166 wxPyEndAllowThreads(__tstate);
40167 if (PyErr_Occurred()) SWIG_fail;
40168 }
40169 {
40170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40171 }
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40179 PyObject *resultobj = 0;
40180 wxMenu *arg1 = (wxMenu *) 0 ;
40181 size_t result;
40182 void *argp1 = 0 ;
40183 int res1 = 0 ;
40184 PyObject *swig_obj[1] ;
40185
40186 if (!args) SWIG_fail;
40187 swig_obj[0] = args;
40188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40191 }
40192 arg1 = reinterpret_cast< wxMenu * >(argp1);
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40207 PyObject *resultobj = 0;
40208 wxMenu *arg1 = (wxMenu *) 0 ;
40209 PyObject *result = 0 ;
40210 void *argp1 = 0 ;
40211 int res1 = 0 ;
40212 PyObject *swig_obj[1] ;
40213
40214 if (!args) SWIG_fail;
40215 swig_obj[0] = args;
40216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40217 if (!SWIG_IsOK(res1)) {
40218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40219 }
40220 arg1 = reinterpret_cast< wxMenu * >(argp1);
40221 {
40222 PyThreadState* __tstate = wxPyBeginAllowThreads();
40223 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40224 wxPyEndAllowThreads(__tstate);
40225 if (PyErr_Occurred()) SWIG_fail;
40226 }
40227 resultobj = result;
40228 return resultobj;
40229 fail:
40230 return NULL;
40231 }
40232
40233
40234 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40235 PyObject *resultobj = 0;
40236 wxMenu *arg1 = (wxMenu *) 0 ;
40237 wxString *arg2 = 0 ;
40238 int result;
40239 void *argp1 = 0 ;
40240 int res1 = 0 ;
40241 bool temp2 = false ;
40242 PyObject * obj0 = 0 ;
40243 PyObject * obj1 = 0 ;
40244 char * kwnames[] = {
40245 (char *) "self",(char *) "item", NULL
40246 };
40247
40248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40250 if (!SWIG_IsOK(res1)) {
40251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40252 }
40253 arg1 = reinterpret_cast< wxMenu * >(argp1);
40254 {
40255 arg2 = wxString_in_helper(obj1);
40256 if (arg2 == NULL) SWIG_fail;
40257 temp2 = true;
40258 }
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40262 wxPyEndAllowThreads(__tstate);
40263 if (PyErr_Occurred()) SWIG_fail;
40264 }
40265 resultobj = SWIG_From_int(static_cast< int >(result));
40266 {
40267 if (temp2)
40268 delete arg2;
40269 }
40270 return resultobj;
40271 fail:
40272 {
40273 if (temp2)
40274 delete arg2;
40275 }
40276 return NULL;
40277 }
40278
40279
40280 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40281 PyObject *resultobj = 0;
40282 wxMenu *arg1 = (wxMenu *) 0 ;
40283 int arg2 ;
40284 wxMenuItem *result = 0 ;
40285 void *argp1 = 0 ;
40286 int res1 = 0 ;
40287 int val2 ;
40288 int ecode2 = 0 ;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char * kwnames[] = {
40292 (char *) "self",(char *) "id", NULL
40293 };
40294
40295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40297 if (!SWIG_IsOK(res1)) {
40298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40299 }
40300 arg1 = reinterpret_cast< wxMenu * >(argp1);
40301 ecode2 = SWIG_AsVal_int(obj1, &val2);
40302 if (!SWIG_IsOK(ecode2)) {
40303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40304 }
40305 arg2 = static_cast< int >(val2);
40306 {
40307 PyThreadState* __tstate = wxPyBeginAllowThreads();
40308 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40309 wxPyEndAllowThreads(__tstate);
40310 if (PyErr_Occurred()) SWIG_fail;
40311 }
40312 {
40313 resultobj = wxPyMake_wxObject(result, (bool)0);
40314 }
40315 return resultobj;
40316 fail:
40317 return NULL;
40318 }
40319
40320
40321 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40322 PyObject *resultobj = 0;
40323 wxMenu *arg1 = (wxMenu *) 0 ;
40324 size_t arg2 ;
40325 wxMenuItem *result = 0 ;
40326 void *argp1 = 0 ;
40327 int res1 = 0 ;
40328 size_t val2 ;
40329 int ecode2 = 0 ;
40330 PyObject * obj0 = 0 ;
40331 PyObject * obj1 = 0 ;
40332 char * kwnames[] = {
40333 (char *) "self",(char *) "position", NULL
40334 };
40335
40336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40338 if (!SWIG_IsOK(res1)) {
40339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40340 }
40341 arg1 = reinterpret_cast< wxMenu * >(argp1);
40342 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40343 if (!SWIG_IsOK(ecode2)) {
40344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40345 }
40346 arg2 = static_cast< size_t >(val2);
40347 {
40348 PyThreadState* __tstate = wxPyBeginAllowThreads();
40349 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40350 wxPyEndAllowThreads(__tstate);
40351 if (PyErr_Occurred()) SWIG_fail;
40352 }
40353 {
40354 resultobj = wxPyMake_wxObject(result, (bool)0);
40355 }
40356 return resultobj;
40357 fail:
40358 return NULL;
40359 }
40360
40361
40362 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40363 PyObject *resultobj = 0;
40364 wxMenu *arg1 = (wxMenu *) 0 ;
40365 int arg2 ;
40366 bool arg3 ;
40367 void *argp1 = 0 ;
40368 int res1 = 0 ;
40369 int val2 ;
40370 int ecode2 = 0 ;
40371 bool val3 ;
40372 int ecode3 = 0 ;
40373 PyObject * obj0 = 0 ;
40374 PyObject * obj1 = 0 ;
40375 PyObject * obj2 = 0 ;
40376 char * kwnames[] = {
40377 (char *) "self",(char *) "id",(char *) "enable", NULL
40378 };
40379
40380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40382 if (!SWIG_IsOK(res1)) {
40383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40384 }
40385 arg1 = reinterpret_cast< wxMenu * >(argp1);
40386 ecode2 = SWIG_AsVal_int(obj1, &val2);
40387 if (!SWIG_IsOK(ecode2)) {
40388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40389 }
40390 arg2 = static_cast< int >(val2);
40391 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40392 if (!SWIG_IsOK(ecode3)) {
40393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40394 }
40395 arg3 = static_cast< bool >(val3);
40396 {
40397 PyThreadState* __tstate = wxPyBeginAllowThreads();
40398 (arg1)->Enable(arg2,arg3);
40399 wxPyEndAllowThreads(__tstate);
40400 if (PyErr_Occurred()) SWIG_fail;
40401 }
40402 resultobj = SWIG_Py_Void();
40403 return resultobj;
40404 fail:
40405 return NULL;
40406 }
40407
40408
40409 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj = 0;
40411 wxMenu *arg1 = (wxMenu *) 0 ;
40412 int arg2 ;
40413 bool result;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 int val2 ;
40417 int ecode2 = 0 ;
40418 PyObject * obj0 = 0 ;
40419 PyObject * obj1 = 0 ;
40420 char * kwnames[] = {
40421 (char *) "self",(char *) "id", NULL
40422 };
40423
40424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40426 if (!SWIG_IsOK(res1)) {
40427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40428 }
40429 arg1 = reinterpret_cast< wxMenu * >(argp1);
40430 ecode2 = SWIG_AsVal_int(obj1, &val2);
40431 if (!SWIG_IsOK(ecode2)) {
40432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40433 }
40434 arg2 = static_cast< int >(val2);
40435 {
40436 PyThreadState* __tstate = wxPyBeginAllowThreads();
40437 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 {
40442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40443 }
40444 return resultobj;
40445 fail:
40446 return NULL;
40447 }
40448
40449
40450 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40451 PyObject *resultobj = 0;
40452 wxMenu *arg1 = (wxMenu *) 0 ;
40453 int arg2 ;
40454 bool arg3 ;
40455 void *argp1 = 0 ;
40456 int res1 = 0 ;
40457 int val2 ;
40458 int ecode2 = 0 ;
40459 bool val3 ;
40460 int ecode3 = 0 ;
40461 PyObject * obj0 = 0 ;
40462 PyObject * obj1 = 0 ;
40463 PyObject * obj2 = 0 ;
40464 char * kwnames[] = {
40465 (char *) "self",(char *) "id",(char *) "check", NULL
40466 };
40467
40468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40470 if (!SWIG_IsOK(res1)) {
40471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40472 }
40473 arg1 = reinterpret_cast< wxMenu * >(argp1);
40474 ecode2 = SWIG_AsVal_int(obj1, &val2);
40475 if (!SWIG_IsOK(ecode2)) {
40476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40477 }
40478 arg2 = static_cast< int >(val2);
40479 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40480 if (!SWIG_IsOK(ecode3)) {
40481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40482 }
40483 arg3 = static_cast< bool >(val3);
40484 {
40485 PyThreadState* __tstate = wxPyBeginAllowThreads();
40486 (arg1)->Check(arg2,arg3);
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 resultobj = SWIG_Py_Void();
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = 0;
40499 wxMenu *arg1 = (wxMenu *) 0 ;
40500 int arg2 ;
40501 bool 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_IsChecked",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_IsChecked" "', 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_IsChecked" "', expected argument " "2"" of type '" "int""'");
40521 }
40522 arg2 = static_cast< int >(val2);
40523 {
40524 PyThreadState* __tstate = wxPyBeginAllowThreads();
40525 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40526 wxPyEndAllowThreads(__tstate);
40527 if (PyErr_Occurred()) SWIG_fail;
40528 }
40529 {
40530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40531 }
40532 return resultobj;
40533 fail:
40534 return NULL;
40535 }
40536
40537
40538 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40539 PyObject *resultobj = 0;
40540 wxMenu *arg1 = (wxMenu *) 0 ;
40541 int arg2 ;
40542 wxString *arg3 = 0 ;
40543 void *argp1 = 0 ;
40544 int res1 = 0 ;
40545 int val2 ;
40546 int ecode2 = 0 ;
40547 bool temp3 = false ;
40548 PyObject * obj0 = 0 ;
40549 PyObject * obj1 = 0 ;
40550 PyObject * obj2 = 0 ;
40551 char * kwnames[] = {
40552 (char *) "self",(char *) "id",(char *) "label", NULL
40553 };
40554
40555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) 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_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40559 }
40560 arg1 = reinterpret_cast< wxMenu * >(argp1);
40561 ecode2 = SWIG_AsVal_int(obj1, &val2);
40562 if (!SWIG_IsOK(ecode2)) {
40563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40564 }
40565 arg2 = static_cast< int >(val2);
40566 {
40567 arg3 = wxString_in_helper(obj2);
40568 if (arg3 == NULL) SWIG_fail;
40569 temp3 = true;
40570 }
40571 {
40572 PyThreadState* __tstate = wxPyBeginAllowThreads();
40573 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40574 wxPyEndAllowThreads(__tstate);
40575 if (PyErr_Occurred()) SWIG_fail;
40576 }
40577 resultobj = SWIG_Py_Void();
40578 {
40579 if (temp3)
40580 delete arg3;
40581 }
40582 return resultobj;
40583 fail:
40584 {
40585 if (temp3)
40586 delete arg3;
40587 }
40588 return NULL;
40589 }
40590
40591
40592 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40593 PyObject *resultobj = 0;
40594 wxMenu *arg1 = (wxMenu *) 0 ;
40595 int arg2 ;
40596 wxString result;
40597 void *argp1 = 0 ;
40598 int res1 = 0 ;
40599 int val2 ;
40600 int ecode2 = 0 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 char * kwnames[] = {
40604 (char *) "self",(char *) "id", NULL
40605 };
40606
40607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40609 if (!SWIG_IsOK(res1)) {
40610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40611 }
40612 arg1 = reinterpret_cast< wxMenu * >(argp1);
40613 ecode2 = SWIG_AsVal_int(obj1, &val2);
40614 if (!SWIG_IsOK(ecode2)) {
40615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40616 }
40617 arg2 = static_cast< int >(val2);
40618 {
40619 PyThreadState* __tstate = wxPyBeginAllowThreads();
40620 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40621 wxPyEndAllowThreads(__tstate);
40622 if (PyErr_Occurred()) SWIG_fail;
40623 }
40624 {
40625 #if wxUSE_UNICODE
40626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40627 #else
40628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40629 #endif
40630 }
40631 return resultobj;
40632 fail:
40633 return NULL;
40634 }
40635
40636
40637 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40638 PyObject *resultobj = 0;
40639 wxMenu *arg1 = (wxMenu *) 0 ;
40640 int arg2 ;
40641 wxString *arg3 = 0 ;
40642 void *argp1 = 0 ;
40643 int res1 = 0 ;
40644 int val2 ;
40645 int ecode2 = 0 ;
40646 bool temp3 = false ;
40647 PyObject * obj0 = 0 ;
40648 PyObject * obj1 = 0 ;
40649 PyObject * obj2 = 0 ;
40650 char * kwnames[] = {
40651 (char *) "self",(char *) "id",(char *) "helpString", NULL
40652 };
40653
40654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40656 if (!SWIG_IsOK(res1)) {
40657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40658 }
40659 arg1 = reinterpret_cast< wxMenu * >(argp1);
40660 ecode2 = SWIG_AsVal_int(obj1, &val2);
40661 if (!SWIG_IsOK(ecode2)) {
40662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40663 }
40664 arg2 = static_cast< int >(val2);
40665 {
40666 arg3 = wxString_in_helper(obj2);
40667 if (arg3 == NULL) SWIG_fail;
40668 temp3 = true;
40669 }
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40673 wxPyEndAllowThreads(__tstate);
40674 if (PyErr_Occurred()) SWIG_fail;
40675 }
40676 resultobj = SWIG_Py_Void();
40677 {
40678 if (temp3)
40679 delete arg3;
40680 }
40681 return resultobj;
40682 fail:
40683 {
40684 if (temp3)
40685 delete arg3;
40686 }
40687 return NULL;
40688 }
40689
40690
40691 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40692 PyObject *resultobj = 0;
40693 wxMenu *arg1 = (wxMenu *) 0 ;
40694 int arg2 ;
40695 wxString result;
40696 void *argp1 = 0 ;
40697 int res1 = 0 ;
40698 int val2 ;
40699 int ecode2 = 0 ;
40700 PyObject * obj0 = 0 ;
40701 PyObject * obj1 = 0 ;
40702 char * kwnames[] = {
40703 (char *) "self",(char *) "id", NULL
40704 };
40705
40706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40708 if (!SWIG_IsOK(res1)) {
40709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40710 }
40711 arg1 = reinterpret_cast< wxMenu * >(argp1);
40712 ecode2 = SWIG_AsVal_int(obj1, &val2);
40713 if (!SWIG_IsOK(ecode2)) {
40714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40715 }
40716 arg2 = static_cast< int >(val2);
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 {
40724 #if wxUSE_UNICODE
40725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40726 #else
40727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40728 #endif
40729 }
40730 return resultobj;
40731 fail:
40732 return NULL;
40733 }
40734
40735
40736 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40737 PyObject *resultobj = 0;
40738 wxMenu *arg1 = (wxMenu *) 0 ;
40739 wxString *arg2 = 0 ;
40740 void *argp1 = 0 ;
40741 int res1 = 0 ;
40742 bool temp2 = false ;
40743 PyObject * obj0 = 0 ;
40744 PyObject * obj1 = 0 ;
40745 char * kwnames[] = {
40746 (char *) "self",(char *) "title", NULL
40747 };
40748
40749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40751 if (!SWIG_IsOK(res1)) {
40752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40753 }
40754 arg1 = reinterpret_cast< wxMenu * >(argp1);
40755 {
40756 arg2 = wxString_in_helper(obj1);
40757 if (arg2 == NULL) SWIG_fail;
40758 temp2 = true;
40759 }
40760 {
40761 PyThreadState* __tstate = wxPyBeginAllowThreads();
40762 (arg1)->SetTitle((wxString const &)*arg2);
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 resultobj = SWIG_Py_Void();
40767 {
40768 if (temp2)
40769 delete arg2;
40770 }
40771 return resultobj;
40772 fail:
40773 {
40774 if (temp2)
40775 delete arg2;
40776 }
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40782 PyObject *resultobj = 0;
40783 wxMenu *arg1 = (wxMenu *) 0 ;
40784 wxString result;
40785 void *argp1 = 0 ;
40786 int res1 = 0 ;
40787 PyObject *swig_obj[1] ;
40788
40789 if (!args) SWIG_fail;
40790 swig_obj[0] = args;
40791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40792 if (!SWIG_IsOK(res1)) {
40793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40794 }
40795 arg1 = reinterpret_cast< wxMenu * >(argp1);
40796 {
40797 PyThreadState* __tstate = wxPyBeginAllowThreads();
40798 result = ((wxMenu const *)arg1)->GetTitle();
40799 wxPyEndAllowThreads(__tstate);
40800 if (PyErr_Occurred()) SWIG_fail;
40801 }
40802 {
40803 #if wxUSE_UNICODE
40804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40805 #else
40806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40807 #endif
40808 }
40809 return resultobj;
40810 fail:
40811 return NULL;
40812 }
40813
40814
40815 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40816 PyObject *resultobj = 0;
40817 wxMenu *arg1 = (wxMenu *) 0 ;
40818 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40819 void *argp1 = 0 ;
40820 int res1 = 0 ;
40821 void *argp2 = 0 ;
40822 int res2 = 0 ;
40823 PyObject * obj0 = 0 ;
40824 PyObject * obj1 = 0 ;
40825 char * kwnames[] = {
40826 (char *) "self",(char *) "handler", NULL
40827 };
40828
40829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40831 if (!SWIG_IsOK(res1)) {
40832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40833 }
40834 arg1 = reinterpret_cast< wxMenu * >(argp1);
40835 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40836 if (!SWIG_IsOK(res2)) {
40837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40838 }
40839 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 (arg1)->SetEventHandler(arg2);
40843 wxPyEndAllowThreads(__tstate);
40844 if (PyErr_Occurred()) SWIG_fail;
40845 }
40846 resultobj = SWIG_Py_Void();
40847 return resultobj;
40848 fail:
40849 return NULL;
40850 }
40851
40852
40853 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40854 PyObject *resultobj = 0;
40855 wxMenu *arg1 = (wxMenu *) 0 ;
40856 wxEvtHandler *result = 0 ;
40857 void *argp1 = 0 ;
40858 int res1 = 0 ;
40859 PyObject *swig_obj[1] ;
40860
40861 if (!args) SWIG_fail;
40862 swig_obj[0] = args;
40863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40864 if (!SWIG_IsOK(res1)) {
40865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40866 }
40867 arg1 = reinterpret_cast< wxMenu * >(argp1);
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40871 wxPyEndAllowThreads(__tstate);
40872 if (PyErr_Occurred()) SWIG_fail;
40873 }
40874 {
40875 resultobj = wxPyMake_wxObject(result, 0);
40876 }
40877 return resultobj;
40878 fail:
40879 return NULL;
40880 }
40881
40882
40883 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40884 PyObject *resultobj = 0;
40885 wxMenu *arg1 = (wxMenu *) 0 ;
40886 wxWindow *arg2 = (wxWindow *) 0 ;
40887 void *argp1 = 0 ;
40888 int res1 = 0 ;
40889 void *argp2 = 0 ;
40890 int res2 = 0 ;
40891 PyObject * obj0 = 0 ;
40892 PyObject * obj1 = 0 ;
40893 char * kwnames[] = {
40894 (char *) "self",(char *) "win", NULL
40895 };
40896
40897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40899 if (!SWIG_IsOK(res1)) {
40900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40901 }
40902 arg1 = reinterpret_cast< wxMenu * >(argp1);
40903 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40904 if (!SWIG_IsOK(res2)) {
40905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40906 }
40907 arg2 = reinterpret_cast< wxWindow * >(argp2);
40908 {
40909 PyThreadState* __tstate = wxPyBeginAllowThreads();
40910 (arg1)->SetInvokingWindow(arg2);
40911 wxPyEndAllowThreads(__tstate);
40912 if (PyErr_Occurred()) SWIG_fail;
40913 }
40914 resultobj = SWIG_Py_Void();
40915 return resultobj;
40916 fail:
40917 return NULL;
40918 }
40919
40920
40921 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40922 PyObject *resultobj = 0;
40923 wxMenu *arg1 = (wxMenu *) 0 ;
40924 wxWindow *result = 0 ;
40925 void *argp1 = 0 ;
40926 int res1 = 0 ;
40927 PyObject *swig_obj[1] ;
40928
40929 if (!args) SWIG_fail;
40930 swig_obj[0] = args;
40931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40932 if (!SWIG_IsOK(res1)) {
40933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40934 }
40935 arg1 = reinterpret_cast< wxMenu * >(argp1);
40936 {
40937 PyThreadState* __tstate = wxPyBeginAllowThreads();
40938 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40939 wxPyEndAllowThreads(__tstate);
40940 if (PyErr_Occurred()) SWIG_fail;
40941 }
40942 {
40943 resultobj = wxPyMake_wxObject(result, 0);
40944 }
40945 return resultobj;
40946 fail:
40947 return NULL;
40948 }
40949
40950
40951 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40952 PyObject *resultobj = 0;
40953 wxMenu *arg1 = (wxMenu *) 0 ;
40954 long result;
40955 void *argp1 = 0 ;
40956 int res1 = 0 ;
40957 PyObject *swig_obj[1] ;
40958
40959 if (!args) SWIG_fail;
40960 swig_obj[0] = args;
40961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40962 if (!SWIG_IsOK(res1)) {
40963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40964 }
40965 arg1 = reinterpret_cast< wxMenu * >(argp1);
40966 {
40967 PyThreadState* __tstate = wxPyBeginAllowThreads();
40968 result = (long)((wxMenu const *)arg1)->GetStyle();
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 resultobj = SWIG_From_long(static_cast< long >(result));
40973 return resultobj;
40974 fail:
40975 return NULL;
40976 }
40977
40978
40979 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40980 PyObject *resultobj = 0;
40981 wxMenu *arg1 = (wxMenu *) 0 ;
40982 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40983 void *argp1 = 0 ;
40984 int res1 = 0 ;
40985 void *argp2 = 0 ;
40986 int res2 = 0 ;
40987 PyObject * obj0 = 0 ;
40988 PyObject * obj1 = 0 ;
40989 char * kwnames[] = {
40990 (char *) "self",(char *) "source", NULL
40991 };
40992
40993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40995 if (!SWIG_IsOK(res1)) {
40996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40997 }
40998 arg1 = reinterpret_cast< wxMenu * >(argp1);
40999 if (obj1) {
41000 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41001 if (!SWIG_IsOK(res2)) {
41002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41003 }
41004 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41005 }
41006 {
41007 PyThreadState* __tstate = wxPyBeginAllowThreads();
41008 (arg1)->UpdateUI(arg2);
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 resultobj = SWIG_Py_Void();
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41020 PyObject *resultobj = 0;
41021 wxMenu *arg1 = (wxMenu *) 0 ;
41022 wxMenuBar *result = 0 ;
41023 void *argp1 = 0 ;
41024 int res1 = 0 ;
41025 PyObject *swig_obj[1] ;
41026
41027 if (!args) SWIG_fail;
41028 swig_obj[0] = args;
41029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41030 if (!SWIG_IsOK(res1)) {
41031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41032 }
41033 arg1 = reinterpret_cast< wxMenu * >(argp1);
41034 {
41035 PyThreadState* __tstate = wxPyBeginAllowThreads();
41036 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41037 wxPyEndAllowThreads(__tstate);
41038 if (PyErr_Occurred()) SWIG_fail;
41039 }
41040 {
41041 resultobj = wxPyMake_wxObject(result, (bool)0);
41042 }
41043 return resultobj;
41044 fail:
41045 return NULL;
41046 }
41047
41048
41049 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41050 PyObject *resultobj = 0;
41051 wxMenu *arg1 = (wxMenu *) 0 ;
41052 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41053 void *argp1 = 0 ;
41054 int res1 = 0 ;
41055 void *argp2 = 0 ;
41056 int res2 = 0 ;
41057 PyObject * obj0 = 0 ;
41058 PyObject * obj1 = 0 ;
41059 char * kwnames[] = {
41060 (char *) "self",(char *) "menubar", NULL
41061 };
41062
41063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41067 }
41068 arg1 = reinterpret_cast< wxMenu * >(argp1);
41069 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41070 if (!SWIG_IsOK(res2)) {
41071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41072 }
41073 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 (arg1)->Attach(arg2);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 resultobj = SWIG_Py_Void();
41081 return resultobj;
41082 fail:
41083 return NULL;
41084 }
41085
41086
41087 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41088 PyObject *resultobj = 0;
41089 wxMenu *arg1 = (wxMenu *) 0 ;
41090 void *argp1 = 0 ;
41091 int res1 = 0 ;
41092 PyObject *swig_obj[1] ;
41093
41094 if (!args) SWIG_fail;
41095 swig_obj[0] = args;
41096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41097 if (!SWIG_IsOK(res1)) {
41098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41099 }
41100 arg1 = reinterpret_cast< wxMenu * >(argp1);
41101 {
41102 PyThreadState* __tstate = wxPyBeginAllowThreads();
41103 (arg1)->Detach();
41104 wxPyEndAllowThreads(__tstate);
41105 if (PyErr_Occurred()) SWIG_fail;
41106 }
41107 resultobj = SWIG_Py_Void();
41108 return resultobj;
41109 fail:
41110 return NULL;
41111 }
41112
41113
41114 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41115 PyObject *resultobj = 0;
41116 wxMenu *arg1 = (wxMenu *) 0 ;
41117 bool result;
41118 void *argp1 = 0 ;
41119 int res1 = 0 ;
41120 PyObject *swig_obj[1] ;
41121
41122 if (!args) SWIG_fail;
41123 swig_obj[0] = args;
41124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41125 if (!SWIG_IsOK(res1)) {
41126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41127 }
41128 arg1 = reinterpret_cast< wxMenu * >(argp1);
41129 {
41130 PyThreadState* __tstate = wxPyBeginAllowThreads();
41131 result = (bool)((wxMenu const *)arg1)->IsAttached();
41132 wxPyEndAllowThreads(__tstate);
41133 if (PyErr_Occurred()) SWIG_fail;
41134 }
41135 {
41136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41137 }
41138 return resultobj;
41139 fail:
41140 return NULL;
41141 }
41142
41143
41144 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj = 0;
41146 wxMenu *arg1 = (wxMenu *) 0 ;
41147 wxMenu *arg2 = (wxMenu *) 0 ;
41148 void *argp1 = 0 ;
41149 int res1 = 0 ;
41150 void *argp2 = 0 ;
41151 int res2 = 0 ;
41152 PyObject * obj0 = 0 ;
41153 PyObject * obj1 = 0 ;
41154 char * kwnames[] = {
41155 (char *) "self",(char *) "parent", NULL
41156 };
41157
41158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41160 if (!SWIG_IsOK(res1)) {
41161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41162 }
41163 arg1 = reinterpret_cast< wxMenu * >(argp1);
41164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41165 if (!SWIG_IsOK(res2)) {
41166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41167 }
41168 arg2 = reinterpret_cast< wxMenu * >(argp2);
41169 {
41170 PyThreadState* __tstate = wxPyBeginAllowThreads();
41171 (arg1)->SetParent(arg2);
41172 wxPyEndAllowThreads(__tstate);
41173 if (PyErr_Occurred()) SWIG_fail;
41174 }
41175 resultobj = SWIG_Py_Void();
41176 return resultobj;
41177 fail:
41178 return NULL;
41179 }
41180
41181
41182 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41183 PyObject *resultobj = 0;
41184 wxMenu *arg1 = (wxMenu *) 0 ;
41185 wxMenu *result = 0 ;
41186 void *argp1 = 0 ;
41187 int res1 = 0 ;
41188 PyObject *swig_obj[1] ;
41189
41190 if (!args) SWIG_fail;
41191 swig_obj[0] = args;
41192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41193 if (!SWIG_IsOK(res1)) {
41194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41195 }
41196 arg1 = reinterpret_cast< wxMenu * >(argp1);
41197 {
41198 PyThreadState* __tstate = wxPyBeginAllowThreads();
41199 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41200 wxPyEndAllowThreads(__tstate);
41201 if (PyErr_Occurred()) SWIG_fail;
41202 }
41203 {
41204 resultobj = wxPyMake_wxObject(result, 0);
41205 }
41206 return resultobj;
41207 fail:
41208 return NULL;
41209 }
41210
41211
41212 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41213 PyObject *obj;
41214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41215 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41216 return SWIG_Py_Void();
41217 }
41218
41219 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41220 return SWIG_Python_InitShadowInstance(args);
41221 }
41222
41223 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41224 PyObject *resultobj = 0;
41225 long arg1 = (long) 0 ;
41226 wxMenuBar *result = 0 ;
41227 long val1 ;
41228 int ecode1 = 0 ;
41229 PyObject * obj0 = 0 ;
41230 char * kwnames[] = {
41231 (char *) "style", NULL
41232 };
41233
41234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41235 if (obj0) {
41236 ecode1 = SWIG_AsVal_long(obj0, &val1);
41237 if (!SWIG_IsOK(ecode1)) {
41238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41239 }
41240 arg1 = static_cast< long >(val1);
41241 }
41242 {
41243 if (!wxPyCheckForApp()) SWIG_fail;
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (wxMenuBar *)new wxMenuBar(arg1);
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41250 return resultobj;
41251 fail:
41252 return NULL;
41253 }
41254
41255
41256 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41257 PyObject *resultobj = 0;
41258 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41259 wxMenu *arg2 = (wxMenu *) 0 ;
41260 wxString *arg3 = 0 ;
41261 bool result;
41262 void *argp1 = 0 ;
41263 int res1 = 0 ;
41264 void *argp2 = 0 ;
41265 int res2 = 0 ;
41266 bool temp3 = false ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 PyObject * obj2 = 0 ;
41270 char * kwnames[] = {
41271 (char *) "self",(char *) "menu",(char *) "title", NULL
41272 };
41273
41274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41276 if (!SWIG_IsOK(res1)) {
41277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41278 }
41279 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41281 if (!SWIG_IsOK(res2)) {
41282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41283 }
41284 arg2 = reinterpret_cast< wxMenu * >(argp2);
41285 {
41286 arg3 = wxString_in_helper(obj2);
41287 if (arg3 == NULL) SWIG_fail;
41288 temp3 = true;
41289 }
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41293 wxPyEndAllowThreads(__tstate);
41294 if (PyErr_Occurred()) SWIG_fail;
41295 }
41296 {
41297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41298 }
41299 {
41300 if (temp3)
41301 delete arg3;
41302 }
41303 return resultobj;
41304 fail:
41305 {
41306 if (temp3)
41307 delete arg3;
41308 }
41309 return NULL;
41310 }
41311
41312
41313 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41314 PyObject *resultobj = 0;
41315 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41316 size_t arg2 ;
41317 wxMenu *arg3 = (wxMenu *) 0 ;
41318 wxString *arg4 = 0 ;
41319 bool result;
41320 void *argp1 = 0 ;
41321 int res1 = 0 ;
41322 size_t val2 ;
41323 int ecode2 = 0 ;
41324 void *argp3 = 0 ;
41325 int res3 = 0 ;
41326 bool temp4 = false ;
41327 PyObject * obj0 = 0 ;
41328 PyObject * obj1 = 0 ;
41329 PyObject * obj2 = 0 ;
41330 PyObject * obj3 = 0 ;
41331 char * kwnames[] = {
41332 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41333 };
41334
41335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_Insert" "', 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_Insert" "', expected argument " "2"" of type '" "size_t""'");
41344 }
41345 arg2 = static_cast< size_t >(val2);
41346 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41347 if (!SWIG_IsOK(res3)) {
41348 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41349 }
41350 arg3 = reinterpret_cast< wxMenu * >(argp3);
41351 {
41352 arg4 = wxString_in_helper(obj3);
41353 if (arg4 == NULL) SWIG_fail;
41354 temp4 = true;
41355 }
41356 {
41357 PyThreadState* __tstate = wxPyBeginAllowThreads();
41358 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41359 wxPyEndAllowThreads(__tstate);
41360 if (PyErr_Occurred()) SWIG_fail;
41361 }
41362 {
41363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41364 }
41365 {
41366 if (temp4)
41367 delete arg4;
41368 }
41369 return resultobj;
41370 fail:
41371 {
41372 if (temp4)
41373 delete arg4;
41374 }
41375 return NULL;
41376 }
41377
41378
41379 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41380 PyObject *resultobj = 0;
41381 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41382 size_t result;
41383 void *argp1 = 0 ;
41384 int res1 = 0 ;
41385 PyObject *swig_obj[1] ;
41386
41387 if (!args) SWIG_fail;
41388 swig_obj[0] = args;
41389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41390 if (!SWIG_IsOK(res1)) {
41391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41392 }
41393 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41401 return resultobj;
41402 fail:
41403 return NULL;
41404 }
41405
41406
41407 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41408 PyObject *resultobj = 0;
41409 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41410 size_t arg2 ;
41411 wxMenu *result = 0 ;
41412 void *argp1 = 0 ;
41413 int res1 = 0 ;
41414 size_t val2 ;
41415 int ecode2 = 0 ;
41416 PyObject * obj0 = 0 ;
41417 PyObject * obj1 = 0 ;
41418 char * kwnames[] = {
41419 (char *) "self",(char *) "pos", NULL
41420 };
41421
41422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41424 if (!SWIG_IsOK(res1)) {
41425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41426 }
41427 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41429 if (!SWIG_IsOK(ecode2)) {
41430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41431 }
41432 arg2 = static_cast< size_t >(val2);
41433 {
41434 PyThreadState* __tstate = wxPyBeginAllowThreads();
41435 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41436 wxPyEndAllowThreads(__tstate);
41437 if (PyErr_Occurred()) SWIG_fail;
41438 }
41439 {
41440 resultobj = wxPyMake_wxObject(result, 0);
41441 }
41442 return resultobj;
41443 fail:
41444 return NULL;
41445 }
41446
41447
41448 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41449 PyObject *resultobj = 0;
41450 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41451 size_t arg2 ;
41452 wxMenu *arg3 = (wxMenu *) 0 ;
41453 wxString *arg4 = 0 ;
41454 wxMenu *result = 0 ;
41455 void *argp1 = 0 ;
41456 int res1 = 0 ;
41457 size_t val2 ;
41458 int ecode2 = 0 ;
41459 void *argp3 = 0 ;
41460 int res3 = 0 ;
41461 bool temp4 = false ;
41462 PyObject * obj0 = 0 ;
41463 PyObject * obj1 = 0 ;
41464 PyObject * obj2 = 0 ;
41465 PyObject * obj3 = 0 ;
41466 char * kwnames[] = {
41467 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41468 };
41469
41470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41472 if (!SWIG_IsOK(res1)) {
41473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41474 }
41475 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41476 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41477 if (!SWIG_IsOK(ecode2)) {
41478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41479 }
41480 arg2 = static_cast< size_t >(val2);
41481 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41482 if (!SWIG_IsOK(res3)) {
41483 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41484 }
41485 arg3 = reinterpret_cast< wxMenu * >(argp3);
41486 {
41487 arg4 = wxString_in_helper(obj3);
41488 if (arg4 == NULL) SWIG_fail;
41489 temp4 = true;
41490 }
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41494 wxPyEndAllowThreads(__tstate);
41495 if (PyErr_Occurred()) SWIG_fail;
41496 }
41497 {
41498 resultobj = wxPyMake_wxObject(result, 0);
41499 }
41500 {
41501 if (temp4)
41502 delete arg4;
41503 }
41504 return resultobj;
41505 fail:
41506 {
41507 if (temp4)
41508 delete arg4;
41509 }
41510 return NULL;
41511 }
41512
41513
41514 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41515 PyObject *resultobj = 0;
41516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41517 size_t arg2 ;
41518 wxMenu *result = 0 ;
41519 void *argp1 = 0 ;
41520 int res1 = 0 ;
41521 size_t val2 ;
41522 int ecode2 = 0 ;
41523 PyObject * obj0 = 0 ;
41524 PyObject * obj1 = 0 ;
41525 char * kwnames[] = {
41526 (char *) "self",(char *) "pos", NULL
41527 };
41528
41529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41531 if (!SWIG_IsOK(res1)) {
41532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41533 }
41534 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41535 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41536 if (!SWIG_IsOK(ecode2)) {
41537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41538 }
41539 arg2 = static_cast< size_t >(val2);
41540 {
41541 PyThreadState* __tstate = wxPyBeginAllowThreads();
41542 result = (wxMenu *)(arg1)->Remove(arg2);
41543 wxPyEndAllowThreads(__tstate);
41544 if (PyErr_Occurred()) SWIG_fail;
41545 }
41546 {
41547 resultobj = wxPyMake_wxObject(result, 0);
41548 }
41549 return resultobj;
41550 fail:
41551 return NULL;
41552 }
41553
41554
41555 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41556 PyObject *resultobj = 0;
41557 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41558 size_t arg2 ;
41559 bool arg3 ;
41560 void *argp1 = 0 ;
41561 int res1 = 0 ;
41562 size_t val2 ;
41563 int ecode2 = 0 ;
41564 bool val3 ;
41565 int ecode3 = 0 ;
41566 PyObject * obj0 = 0 ;
41567 PyObject * obj1 = 0 ;
41568 PyObject * obj2 = 0 ;
41569 char * kwnames[] = {
41570 (char *) "self",(char *) "pos",(char *) "enable", NULL
41571 };
41572
41573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41575 if (!SWIG_IsOK(res1)) {
41576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41577 }
41578 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41579 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41580 if (!SWIG_IsOK(ecode2)) {
41581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41582 }
41583 arg2 = static_cast< size_t >(val2);
41584 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41585 if (!SWIG_IsOK(ecode3)) {
41586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41587 }
41588 arg3 = static_cast< bool >(val3);
41589 {
41590 PyThreadState* __tstate = wxPyBeginAllowThreads();
41591 (arg1)->EnableTop(arg2,arg3);
41592 wxPyEndAllowThreads(__tstate);
41593 if (PyErr_Occurred()) SWIG_fail;
41594 }
41595 resultobj = SWIG_Py_Void();
41596 return resultobj;
41597 fail:
41598 return NULL;
41599 }
41600
41601
41602 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41603 PyObject *resultobj = 0;
41604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41605 size_t arg2 ;
41606 bool result;
41607 void *argp1 = 0 ;
41608 int res1 = 0 ;
41609 size_t val2 ;
41610 int ecode2 = 0 ;
41611 PyObject * obj0 = 0 ;
41612 PyObject * obj1 = 0 ;
41613 char * kwnames[] = {
41614 (char *) "self",(char *) "pos", NULL
41615 };
41616
41617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41619 if (!SWIG_IsOK(res1)) {
41620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41621 }
41622 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41623 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41624 if (!SWIG_IsOK(ecode2)) {
41625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41626 }
41627 arg2 = static_cast< size_t >(val2);
41628 {
41629 PyThreadState* __tstate = wxPyBeginAllowThreads();
41630 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41631 wxPyEndAllowThreads(__tstate);
41632 if (PyErr_Occurred()) SWIG_fail;
41633 }
41634 {
41635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41636 }
41637 return resultobj;
41638 fail:
41639 return NULL;
41640 }
41641
41642
41643 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41644 PyObject *resultobj = 0;
41645 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41646 size_t arg2 ;
41647 wxString *arg3 = 0 ;
41648 void *argp1 = 0 ;
41649 int res1 = 0 ;
41650 size_t val2 ;
41651 int ecode2 = 0 ;
41652 bool temp3 = false ;
41653 PyObject * obj0 = 0 ;
41654 PyObject * obj1 = 0 ;
41655 PyObject * obj2 = 0 ;
41656 char * kwnames[] = {
41657 (char *) "self",(char *) "pos",(char *) "label", NULL
41658 };
41659
41660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41662 if (!SWIG_IsOK(res1)) {
41663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41664 }
41665 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41666 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41667 if (!SWIG_IsOK(ecode2)) {
41668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41669 }
41670 arg2 = static_cast< size_t >(val2);
41671 {
41672 arg3 = wxString_in_helper(obj2);
41673 if (arg3 == NULL) SWIG_fail;
41674 temp3 = true;
41675 }
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41679 wxPyEndAllowThreads(__tstate);
41680 if (PyErr_Occurred()) SWIG_fail;
41681 }
41682 resultobj = SWIG_Py_Void();
41683 {
41684 if (temp3)
41685 delete arg3;
41686 }
41687 return resultobj;
41688 fail:
41689 {
41690 if (temp3)
41691 delete arg3;
41692 }
41693 return NULL;
41694 }
41695
41696
41697 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41698 PyObject *resultobj = 0;
41699 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41700 size_t arg2 ;
41701 wxString result;
41702 void *argp1 = 0 ;
41703 int res1 = 0 ;
41704 size_t val2 ;
41705 int ecode2 = 0 ;
41706 PyObject * obj0 = 0 ;
41707 PyObject * obj1 = 0 ;
41708 char * kwnames[] = {
41709 (char *) "self",(char *) "pos", NULL
41710 };
41711
41712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41714 if (!SWIG_IsOK(res1)) {
41715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41716 }
41717 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41718 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41719 if (!SWIG_IsOK(ecode2)) {
41720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41721 }
41722 arg2 = static_cast< size_t >(val2);
41723 {
41724 PyThreadState* __tstate = wxPyBeginAllowThreads();
41725 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 {
41730 #if wxUSE_UNICODE
41731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41732 #else
41733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41734 #endif
41735 }
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41743 PyObject *resultobj = 0;
41744 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41745 wxString *arg2 = 0 ;
41746 wxString *arg3 = 0 ;
41747 int result;
41748 void *argp1 = 0 ;
41749 int res1 = 0 ;
41750 bool temp2 = false ;
41751 bool temp3 = false ;
41752 PyObject * obj0 = 0 ;
41753 PyObject * obj1 = 0 ;
41754 PyObject * obj2 = 0 ;
41755 char * kwnames[] = {
41756 (char *) "self",(char *) "menu",(char *) "item", NULL
41757 };
41758
41759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41761 if (!SWIG_IsOK(res1)) {
41762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41763 }
41764 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41765 {
41766 arg2 = wxString_in_helper(obj1);
41767 if (arg2 == NULL) SWIG_fail;
41768 temp2 = true;
41769 }
41770 {
41771 arg3 = wxString_in_helper(obj2);
41772 if (arg3 == NULL) SWIG_fail;
41773 temp3 = true;
41774 }
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 resultobj = SWIG_From_int(static_cast< int >(result));
41782 {
41783 if (temp2)
41784 delete arg2;
41785 }
41786 {
41787 if (temp3)
41788 delete arg3;
41789 }
41790 return resultobj;
41791 fail:
41792 {
41793 if (temp2)
41794 delete arg2;
41795 }
41796 {
41797 if (temp3)
41798 delete arg3;
41799 }
41800 return NULL;
41801 }
41802
41803
41804 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41805 PyObject *resultobj = 0;
41806 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41807 int arg2 ;
41808 wxMenuItem *result = 0 ;
41809 void *argp1 = 0 ;
41810 int res1 = 0 ;
41811 int val2 ;
41812 int ecode2 = 0 ;
41813 PyObject * obj0 = 0 ;
41814 PyObject * obj1 = 0 ;
41815 char * kwnames[] = {
41816 (char *) "self",(char *) "id", NULL
41817 };
41818
41819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41821 if (!SWIG_IsOK(res1)) {
41822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41823 }
41824 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41825 ecode2 = SWIG_AsVal_int(obj1, &val2);
41826 if (!SWIG_IsOK(ecode2)) {
41827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41828 }
41829 arg2 = static_cast< int >(val2);
41830 {
41831 PyThreadState* __tstate = wxPyBeginAllowThreads();
41832 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41833 wxPyEndAllowThreads(__tstate);
41834 if (PyErr_Occurred()) SWIG_fail;
41835 }
41836 {
41837 resultobj = wxPyMake_wxObject(result, (bool)0);
41838 }
41839 return resultobj;
41840 fail:
41841 return NULL;
41842 }
41843
41844
41845 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41846 PyObject *resultobj = 0;
41847 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41848 wxString *arg2 = 0 ;
41849 int result;
41850 void *argp1 = 0 ;
41851 int res1 = 0 ;
41852 bool temp2 = false ;
41853 PyObject * obj0 = 0 ;
41854 PyObject * obj1 = 0 ;
41855 char * kwnames[] = {
41856 (char *) "self",(char *) "title", NULL
41857 };
41858
41859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41861 if (!SWIG_IsOK(res1)) {
41862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41863 }
41864 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41865 {
41866 arg2 = wxString_in_helper(obj1);
41867 if (arg2 == NULL) SWIG_fail;
41868 temp2 = true;
41869 }
41870 {
41871 PyThreadState* __tstate = wxPyBeginAllowThreads();
41872 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 resultobj = SWIG_From_int(static_cast< int >(result));
41877 {
41878 if (temp2)
41879 delete arg2;
41880 }
41881 return resultobj;
41882 fail:
41883 {
41884 if (temp2)
41885 delete arg2;
41886 }
41887 return NULL;
41888 }
41889
41890
41891 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41892 PyObject *resultobj = 0;
41893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41894 int arg2 ;
41895 bool arg3 ;
41896 void *argp1 = 0 ;
41897 int res1 = 0 ;
41898 int val2 ;
41899 int ecode2 = 0 ;
41900 bool val3 ;
41901 int ecode3 = 0 ;
41902 PyObject * obj0 = 0 ;
41903 PyObject * obj1 = 0 ;
41904 PyObject * obj2 = 0 ;
41905 char * kwnames[] = {
41906 (char *) "self",(char *) "id",(char *) "enable", NULL
41907 };
41908
41909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41911 if (!SWIG_IsOK(res1)) {
41912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41913 }
41914 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41915 ecode2 = SWIG_AsVal_int(obj1, &val2);
41916 if (!SWIG_IsOK(ecode2)) {
41917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41918 }
41919 arg2 = static_cast< int >(val2);
41920 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41921 if (!SWIG_IsOK(ecode3)) {
41922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41923 }
41924 arg3 = static_cast< bool >(val3);
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 (arg1)->Enable(arg2,arg3);
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 resultobj = SWIG_Py_Void();
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj = 0;
41940 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41941 int arg2 ;
41942 bool arg3 ;
41943 void *argp1 = 0 ;
41944 int res1 = 0 ;
41945 int val2 ;
41946 int ecode2 = 0 ;
41947 bool val3 ;
41948 int ecode3 = 0 ;
41949 PyObject * obj0 = 0 ;
41950 PyObject * obj1 = 0 ;
41951 PyObject * obj2 = 0 ;
41952 char * kwnames[] = {
41953 (char *) "self",(char *) "id",(char *) "check", NULL
41954 };
41955
41956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41958 if (!SWIG_IsOK(res1)) {
41959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41960 }
41961 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41962 ecode2 = SWIG_AsVal_int(obj1, &val2);
41963 if (!SWIG_IsOK(ecode2)) {
41964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41965 }
41966 arg2 = static_cast< int >(val2);
41967 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41968 if (!SWIG_IsOK(ecode3)) {
41969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41970 }
41971 arg3 = static_cast< bool >(val3);
41972 {
41973 PyThreadState* __tstate = wxPyBeginAllowThreads();
41974 (arg1)->Check(arg2,arg3);
41975 wxPyEndAllowThreads(__tstate);
41976 if (PyErr_Occurred()) SWIG_fail;
41977 }
41978 resultobj = SWIG_Py_Void();
41979 return resultobj;
41980 fail:
41981 return NULL;
41982 }
41983
41984
41985 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41986 PyObject *resultobj = 0;
41987 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41988 int arg2 ;
41989 bool result;
41990 void *argp1 = 0 ;
41991 int res1 = 0 ;
41992 int val2 ;
41993 int ecode2 = 0 ;
41994 PyObject * obj0 = 0 ;
41995 PyObject * obj1 = 0 ;
41996 char * kwnames[] = {
41997 (char *) "self",(char *) "id", NULL
41998 };
41999
42000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42002 if (!SWIG_IsOK(res1)) {
42003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42004 }
42005 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42006 ecode2 = SWIG_AsVal_int(obj1, &val2);
42007 if (!SWIG_IsOK(ecode2)) {
42008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42009 }
42010 arg2 = static_cast< int >(val2);
42011 {
42012 PyThreadState* __tstate = wxPyBeginAllowThreads();
42013 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42014 wxPyEndAllowThreads(__tstate);
42015 if (PyErr_Occurred()) SWIG_fail;
42016 }
42017 {
42018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42019 }
42020 return resultobj;
42021 fail:
42022 return NULL;
42023 }
42024
42025
42026 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42027 PyObject *resultobj = 0;
42028 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42029 int arg2 ;
42030 bool 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_IsEnabled",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_IsEnabled" "', 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_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42050 }
42051 arg2 = static_cast< int >(val2);
42052 {
42053 PyThreadState* __tstate = wxPyBeginAllowThreads();
42054 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42055 wxPyEndAllowThreads(__tstate);
42056 if (PyErr_Occurred()) SWIG_fail;
42057 }
42058 {
42059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42060 }
42061 return resultobj;
42062 fail:
42063 return NULL;
42064 }
42065
42066
42067 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42068 PyObject *resultobj = 0;
42069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42070 int arg2 ;
42071 wxString *arg3 = 0 ;
42072 void *argp1 = 0 ;
42073 int res1 = 0 ;
42074 int val2 ;
42075 int ecode2 = 0 ;
42076 bool temp3 = false ;
42077 PyObject * obj0 = 0 ;
42078 PyObject * obj1 = 0 ;
42079 PyObject * obj2 = 0 ;
42080 char * kwnames[] = {
42081 (char *) "self",(char *) "id",(char *) "label", NULL
42082 };
42083
42084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42086 if (!SWIG_IsOK(res1)) {
42087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42088 }
42089 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42090 ecode2 = SWIG_AsVal_int(obj1, &val2);
42091 if (!SWIG_IsOK(ecode2)) {
42092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42093 }
42094 arg2 = static_cast< int >(val2);
42095 {
42096 arg3 = wxString_in_helper(obj2);
42097 if (arg3 == NULL) SWIG_fail;
42098 temp3 = true;
42099 }
42100 {
42101 PyThreadState* __tstate = wxPyBeginAllowThreads();
42102 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42103 wxPyEndAllowThreads(__tstate);
42104 if (PyErr_Occurred()) SWIG_fail;
42105 }
42106 resultobj = SWIG_Py_Void();
42107 {
42108 if (temp3)
42109 delete arg3;
42110 }
42111 return resultobj;
42112 fail:
42113 {
42114 if (temp3)
42115 delete arg3;
42116 }
42117 return NULL;
42118 }
42119
42120
42121 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42122 PyObject *resultobj = 0;
42123 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42124 int arg2 ;
42125 wxString result;
42126 void *argp1 = 0 ;
42127 int res1 = 0 ;
42128 int val2 ;
42129 int ecode2 = 0 ;
42130 PyObject * obj0 = 0 ;
42131 PyObject * obj1 = 0 ;
42132 char * kwnames[] = {
42133 (char *) "self",(char *) "id", NULL
42134 };
42135
42136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42138 if (!SWIG_IsOK(res1)) {
42139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42140 }
42141 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42142 ecode2 = SWIG_AsVal_int(obj1, &val2);
42143 if (!SWIG_IsOK(ecode2)) {
42144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42145 }
42146 arg2 = static_cast< int >(val2);
42147 {
42148 PyThreadState* __tstate = wxPyBeginAllowThreads();
42149 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 {
42154 #if wxUSE_UNICODE
42155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42156 #else
42157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42158 #endif
42159 }
42160 return resultobj;
42161 fail:
42162 return NULL;
42163 }
42164
42165
42166 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42167 PyObject *resultobj = 0;
42168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42169 int arg2 ;
42170 wxString *arg3 = 0 ;
42171 void *argp1 = 0 ;
42172 int res1 = 0 ;
42173 int val2 ;
42174 int ecode2 = 0 ;
42175 bool temp3 = false ;
42176 PyObject * obj0 = 0 ;
42177 PyObject * obj1 = 0 ;
42178 PyObject * obj2 = 0 ;
42179 char * kwnames[] = {
42180 (char *) "self",(char *) "id",(char *) "helpString", NULL
42181 };
42182
42183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42185 if (!SWIG_IsOK(res1)) {
42186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42187 }
42188 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42189 ecode2 = SWIG_AsVal_int(obj1, &val2);
42190 if (!SWIG_IsOK(ecode2)) {
42191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42192 }
42193 arg2 = static_cast< int >(val2);
42194 {
42195 arg3 = wxString_in_helper(obj2);
42196 if (arg3 == NULL) SWIG_fail;
42197 temp3 = true;
42198 }
42199 {
42200 PyThreadState* __tstate = wxPyBeginAllowThreads();
42201 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42202 wxPyEndAllowThreads(__tstate);
42203 if (PyErr_Occurred()) SWIG_fail;
42204 }
42205 resultobj = SWIG_Py_Void();
42206 {
42207 if (temp3)
42208 delete arg3;
42209 }
42210 return resultobj;
42211 fail:
42212 {
42213 if (temp3)
42214 delete arg3;
42215 }
42216 return NULL;
42217 }
42218
42219
42220 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42221 PyObject *resultobj = 0;
42222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42223 int arg2 ;
42224 wxString result;
42225 void *argp1 = 0 ;
42226 int res1 = 0 ;
42227 int val2 ;
42228 int ecode2 = 0 ;
42229 PyObject * obj0 = 0 ;
42230 PyObject * obj1 = 0 ;
42231 char * kwnames[] = {
42232 (char *) "self",(char *) "id", NULL
42233 };
42234
42235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42237 if (!SWIG_IsOK(res1)) {
42238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42239 }
42240 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42241 ecode2 = SWIG_AsVal_int(obj1, &val2);
42242 if (!SWIG_IsOK(ecode2)) {
42243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42244 }
42245 arg2 = static_cast< int >(val2);
42246 {
42247 PyThreadState* __tstate = wxPyBeginAllowThreads();
42248 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42249 wxPyEndAllowThreads(__tstate);
42250 if (PyErr_Occurred()) SWIG_fail;
42251 }
42252 {
42253 #if wxUSE_UNICODE
42254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42255 #else
42256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42257 #endif
42258 }
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42266 PyObject *resultobj = 0;
42267 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42268 wxFrame *result = 0 ;
42269 void *argp1 = 0 ;
42270 int res1 = 0 ;
42271 PyObject *swig_obj[1] ;
42272
42273 if (!args) SWIG_fail;
42274 swig_obj[0] = args;
42275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42276 if (!SWIG_IsOK(res1)) {
42277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42278 }
42279 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42280 {
42281 PyThreadState* __tstate = wxPyBeginAllowThreads();
42282 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42283 wxPyEndAllowThreads(__tstate);
42284 if (PyErr_Occurred()) SWIG_fail;
42285 }
42286 {
42287 resultobj = wxPyMake_wxObject(result, (bool)0);
42288 }
42289 return resultobj;
42290 fail:
42291 return NULL;
42292 }
42293
42294
42295 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42296 PyObject *resultobj = 0;
42297 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42298 bool result;
42299 void *argp1 = 0 ;
42300 int res1 = 0 ;
42301 PyObject *swig_obj[1] ;
42302
42303 if (!args) SWIG_fail;
42304 swig_obj[0] = args;
42305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42306 if (!SWIG_IsOK(res1)) {
42307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42308 }
42309 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 {
42317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42318 }
42319 return resultobj;
42320 fail:
42321 return NULL;
42322 }
42323
42324
42325 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42326 PyObject *resultobj = 0;
42327 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42328 wxFrame *arg2 = (wxFrame *) 0 ;
42329 void *argp1 = 0 ;
42330 int res1 = 0 ;
42331 void *argp2 = 0 ;
42332 int res2 = 0 ;
42333 PyObject * obj0 = 0 ;
42334 PyObject * obj1 = 0 ;
42335 char * kwnames[] = {
42336 (char *) "self",(char *) "frame", NULL
42337 };
42338
42339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42341 if (!SWIG_IsOK(res1)) {
42342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42343 }
42344 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42346 if (!SWIG_IsOK(res2)) {
42347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42348 }
42349 arg2 = reinterpret_cast< wxFrame * >(argp2);
42350 {
42351 PyThreadState* __tstate = wxPyBeginAllowThreads();
42352 (arg1)->Attach(arg2);
42353 wxPyEndAllowThreads(__tstate);
42354 if (PyErr_Occurred()) SWIG_fail;
42355 }
42356 resultobj = SWIG_Py_Void();
42357 return resultobj;
42358 fail:
42359 return NULL;
42360 }
42361
42362
42363 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42364 PyObject *resultobj = 0;
42365 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42366 void *argp1 = 0 ;
42367 int res1 = 0 ;
42368 PyObject *swig_obj[1] ;
42369
42370 if (!args) SWIG_fail;
42371 swig_obj[0] = args;
42372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42373 if (!SWIG_IsOK(res1)) {
42374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42375 }
42376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42377 {
42378 PyThreadState* __tstate = wxPyBeginAllowThreads();
42379 (arg1)->Detach();
42380 wxPyEndAllowThreads(__tstate);
42381 if (PyErr_Occurred()) SWIG_fail;
42382 }
42383 resultobj = SWIG_Py_Void();
42384 return resultobj;
42385 fail:
42386 return NULL;
42387 }
42388
42389
42390 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42391 PyObject *resultobj = 0;
42392 wxMenuBar *arg1 = (wxMenuBar *) 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_wxMenuBar, 0 | 0 );
42400 if (!SWIG_IsOK(res1)) {
42401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42402 }
42403 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42404 {
42405 PyThreadState* __tstate = wxPyBeginAllowThreads();
42406 (arg1)->UpdateMenus();
42407 wxPyEndAllowThreads(__tstate);
42408 if (PyErr_Occurred()) SWIG_fail;
42409 }
42410 resultobj = SWIG_Py_Void();
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj = 0;
42419 bool arg1 ;
42420 bool val1 ;
42421 int ecode1 = 0 ;
42422 PyObject * obj0 = 0 ;
42423 char * kwnames[] = {
42424 (char *) "enable", NULL
42425 };
42426
42427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42428 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42429 if (!SWIG_IsOK(ecode1)) {
42430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42431 }
42432 arg1 = static_cast< bool >(val1);
42433 {
42434 PyThreadState* __tstate = wxPyBeginAllowThreads();
42435 wxMenuBar_SetAutoWindowMenu(arg1);
42436 wxPyEndAllowThreads(__tstate);
42437 if (PyErr_Occurred()) SWIG_fail;
42438 }
42439 resultobj = SWIG_Py_Void();
42440 return resultobj;
42441 fail:
42442 return NULL;
42443 }
42444
42445
42446 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42447 PyObject *resultobj = 0;
42448 bool result;
42449
42450 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 result = (bool)wxMenuBar_GetAutoWindowMenu();
42454 wxPyEndAllowThreads(__tstate);
42455 if (PyErr_Occurred()) SWIG_fail;
42456 }
42457 {
42458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42459 }
42460 return resultobj;
42461 fail:
42462 return NULL;
42463 }
42464
42465
42466 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42467 PyObject *obj;
42468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42469 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42470 return SWIG_Py_Void();
42471 }
42472
42473 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42474 return SWIG_Python_InitShadowInstance(args);
42475 }
42476
42477 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42478 PyObject *resultobj = 0;
42479 wxMenu *arg1 = (wxMenu *) NULL ;
42480 int arg2 = (int) wxID_ANY ;
42481 wxString const &arg3_defvalue = wxPyEmptyString ;
42482 wxString *arg3 = (wxString *) &arg3_defvalue ;
42483 wxString const &arg4_defvalue = wxPyEmptyString ;
42484 wxString *arg4 = (wxString *) &arg4_defvalue ;
42485 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42486 wxMenu *arg6 = (wxMenu *) NULL ;
42487 wxMenuItem *result = 0 ;
42488 void *argp1 = 0 ;
42489 int res1 = 0 ;
42490 int val2 ;
42491 int ecode2 = 0 ;
42492 bool temp3 = false ;
42493 bool temp4 = false ;
42494 int val5 ;
42495 int ecode5 = 0 ;
42496 void *argp6 = 0 ;
42497 int res6 = 0 ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 PyObject * obj2 = 0 ;
42501 PyObject * obj3 = 0 ;
42502 PyObject * obj4 = 0 ;
42503 PyObject * obj5 = 0 ;
42504 char * kwnames[] = {
42505 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42506 };
42507
42508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42509 if (obj0) {
42510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42511 if (!SWIG_IsOK(res1)) {
42512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42513 }
42514 arg1 = reinterpret_cast< wxMenu * >(argp1);
42515 }
42516 if (obj1) {
42517 ecode2 = SWIG_AsVal_int(obj1, &val2);
42518 if (!SWIG_IsOK(ecode2)) {
42519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42520 }
42521 arg2 = static_cast< int >(val2);
42522 }
42523 if (obj2) {
42524 {
42525 arg3 = wxString_in_helper(obj2);
42526 if (arg3 == NULL) SWIG_fail;
42527 temp3 = true;
42528 }
42529 }
42530 if (obj3) {
42531 {
42532 arg4 = wxString_in_helper(obj3);
42533 if (arg4 == NULL) SWIG_fail;
42534 temp4 = true;
42535 }
42536 }
42537 if (obj4) {
42538 ecode5 = SWIG_AsVal_int(obj4, &val5);
42539 if (!SWIG_IsOK(ecode5)) {
42540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42541 }
42542 arg5 = static_cast< wxItemKind >(val5);
42543 }
42544 if (obj5) {
42545 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42546 if (!SWIG_IsOK(res6)) {
42547 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42548 }
42549 arg6 = reinterpret_cast< wxMenu * >(argp6);
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 {
42558 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42559 }
42560 {
42561 if (temp3)
42562 delete arg3;
42563 }
42564 {
42565 if (temp4)
42566 delete arg4;
42567 }
42568 return resultobj;
42569 fail:
42570 {
42571 if (temp3)
42572 delete arg3;
42573 }
42574 {
42575 if (temp4)
42576 delete arg4;
42577 }
42578 return NULL;
42579 }
42580
42581
42582 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42583 PyObject *resultobj = 0;
42584 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42585 void *argp1 = 0 ;
42586 int res1 = 0 ;
42587 PyObject *swig_obj[1] ;
42588
42589 if (!args) SWIG_fail;
42590 swig_obj[0] = args;
42591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42592 if (!SWIG_IsOK(res1)) {
42593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42594 }
42595 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42596 {
42597 PyThreadState* __tstate = wxPyBeginAllowThreads();
42598 delete arg1;
42599
42600 wxPyEndAllowThreads(__tstate);
42601 if (PyErr_Occurred()) SWIG_fail;
42602 }
42603 resultobj = SWIG_Py_Void();
42604 return resultobj;
42605 fail:
42606 return NULL;
42607 }
42608
42609
42610 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42611 PyObject *resultobj = 0;
42612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42613 wxMenu *result = 0 ;
42614 void *argp1 = 0 ;
42615 int res1 = 0 ;
42616 PyObject *swig_obj[1] ;
42617
42618 if (!args) SWIG_fail;
42619 swig_obj[0] = args;
42620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42621 if (!SWIG_IsOK(res1)) {
42622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42623 }
42624 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42625 {
42626 PyThreadState* __tstate = wxPyBeginAllowThreads();
42627 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42628 wxPyEndAllowThreads(__tstate);
42629 if (PyErr_Occurred()) SWIG_fail;
42630 }
42631 {
42632 resultobj = wxPyMake_wxObject(result, 0);
42633 }
42634 return resultobj;
42635 fail:
42636 return NULL;
42637 }
42638
42639
42640 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42641 PyObject *resultobj = 0;
42642 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42643 wxMenu *arg2 = (wxMenu *) 0 ;
42644 void *argp1 = 0 ;
42645 int res1 = 0 ;
42646 void *argp2 = 0 ;
42647 int res2 = 0 ;
42648 PyObject * obj0 = 0 ;
42649 PyObject * obj1 = 0 ;
42650 char * kwnames[] = {
42651 (char *) "self",(char *) "menu", NULL
42652 };
42653
42654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42656 if (!SWIG_IsOK(res1)) {
42657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42658 }
42659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42661 if (!SWIG_IsOK(res2)) {
42662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42663 }
42664 arg2 = reinterpret_cast< wxMenu * >(argp2);
42665 {
42666 PyThreadState* __tstate = wxPyBeginAllowThreads();
42667 (arg1)->SetMenu(arg2);
42668 wxPyEndAllowThreads(__tstate);
42669 if (PyErr_Occurred()) SWIG_fail;
42670 }
42671 resultobj = SWIG_Py_Void();
42672 return resultobj;
42673 fail:
42674 return NULL;
42675 }
42676
42677
42678 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42679 PyObject *resultobj = 0;
42680 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42681 int arg2 ;
42682 void *argp1 = 0 ;
42683 int res1 = 0 ;
42684 int val2 ;
42685 int ecode2 = 0 ;
42686 PyObject * obj0 = 0 ;
42687 PyObject * obj1 = 0 ;
42688 char * kwnames[] = {
42689 (char *) "self",(char *) "id", NULL
42690 };
42691
42692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42694 if (!SWIG_IsOK(res1)) {
42695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42696 }
42697 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42698 ecode2 = SWIG_AsVal_int(obj1, &val2);
42699 if (!SWIG_IsOK(ecode2)) {
42700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42701 }
42702 arg2 = static_cast< int >(val2);
42703 {
42704 PyThreadState* __tstate = wxPyBeginAllowThreads();
42705 (arg1)->SetId(arg2);
42706 wxPyEndAllowThreads(__tstate);
42707 if (PyErr_Occurred()) SWIG_fail;
42708 }
42709 resultobj = SWIG_Py_Void();
42710 return resultobj;
42711 fail:
42712 return NULL;
42713 }
42714
42715
42716 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42717 PyObject *resultobj = 0;
42718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42719 int result;
42720 void *argp1 = 0 ;
42721 int res1 = 0 ;
42722 PyObject *swig_obj[1] ;
42723
42724 if (!args) SWIG_fail;
42725 swig_obj[0] = args;
42726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42727 if (!SWIG_IsOK(res1)) {
42728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42729 }
42730 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 result = (int)((wxMenuItem const *)arg1)->GetId();
42734 wxPyEndAllowThreads(__tstate);
42735 if (PyErr_Occurred()) SWIG_fail;
42736 }
42737 resultobj = SWIG_From_int(static_cast< int >(result));
42738 return resultobj;
42739 fail:
42740 return NULL;
42741 }
42742
42743
42744 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42745 PyObject *resultobj = 0;
42746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42747 bool result;
42748 void *argp1 = 0 ;
42749 int res1 = 0 ;
42750 PyObject *swig_obj[1] ;
42751
42752 if (!args) SWIG_fail;
42753 swig_obj[0] = args;
42754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42755 if (!SWIG_IsOK(res1)) {
42756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42757 }
42758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 {
42766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42767 }
42768 return resultobj;
42769 fail:
42770 return NULL;
42771 }
42772
42773
42774 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42775 PyObject *resultobj = 0;
42776 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42777 wxString *arg2 = 0 ;
42778 void *argp1 = 0 ;
42779 int res1 = 0 ;
42780 bool temp2 = false ;
42781 PyObject * obj0 = 0 ;
42782 PyObject * obj1 = 0 ;
42783 char * kwnames[] = {
42784 (char *) "self",(char *) "str", NULL
42785 };
42786
42787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42789 if (!SWIG_IsOK(res1)) {
42790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42791 }
42792 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42793 {
42794 arg2 = wxString_in_helper(obj1);
42795 if (arg2 == NULL) SWIG_fail;
42796 temp2 = true;
42797 }
42798 {
42799 PyThreadState* __tstate = wxPyBeginAllowThreads();
42800 (arg1)->SetText((wxString const &)*arg2);
42801 wxPyEndAllowThreads(__tstate);
42802 if (PyErr_Occurred()) SWIG_fail;
42803 }
42804 resultobj = SWIG_Py_Void();
42805 {
42806 if (temp2)
42807 delete arg2;
42808 }
42809 return resultobj;
42810 fail:
42811 {
42812 if (temp2)
42813 delete arg2;
42814 }
42815 return NULL;
42816 }
42817
42818
42819 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42820 PyObject *resultobj = 0;
42821 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42822 wxString result;
42823 void *argp1 = 0 ;
42824 int res1 = 0 ;
42825 PyObject *swig_obj[1] ;
42826
42827 if (!args) SWIG_fail;
42828 swig_obj[0] = args;
42829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42830 if (!SWIG_IsOK(res1)) {
42831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42832 }
42833 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42834 {
42835 PyThreadState* __tstate = wxPyBeginAllowThreads();
42836 result = ((wxMenuItem const *)arg1)->GetLabel();
42837 wxPyEndAllowThreads(__tstate);
42838 if (PyErr_Occurred()) SWIG_fail;
42839 }
42840 {
42841 #if wxUSE_UNICODE
42842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42843 #else
42844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42845 #endif
42846 }
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42854 PyObject *resultobj = 0;
42855 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42856 wxString *result = 0 ;
42857 void *argp1 = 0 ;
42858 int res1 = 0 ;
42859 PyObject *swig_obj[1] ;
42860
42861 if (!args) SWIG_fail;
42862 swig_obj[0] = args;
42863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42864 if (!SWIG_IsOK(res1)) {
42865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42866 }
42867 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42868 {
42869 PyThreadState* __tstate = wxPyBeginAllowThreads();
42870 {
42871 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42872 result = (wxString *) &_result_ref;
42873 }
42874 wxPyEndAllowThreads(__tstate);
42875 if (PyErr_Occurred()) SWIG_fail;
42876 }
42877 {
42878 #if wxUSE_UNICODE
42879 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42880 #else
42881 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42882 #endif
42883 }
42884 return resultobj;
42885 fail:
42886 return NULL;
42887 }
42888
42889
42890 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42891 PyObject *resultobj = 0;
42892 wxString *arg1 = 0 ;
42893 wxString result;
42894 bool temp1 = false ;
42895 PyObject * obj0 = 0 ;
42896 char * kwnames[] = {
42897 (char *) "text", NULL
42898 };
42899
42900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42901 {
42902 arg1 = wxString_in_helper(obj0);
42903 if (arg1 == NULL) SWIG_fail;
42904 temp1 = true;
42905 }
42906 {
42907 PyThreadState* __tstate = wxPyBeginAllowThreads();
42908 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 {
42913 #if wxUSE_UNICODE
42914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42915 #else
42916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42917 #endif
42918 }
42919 {
42920 if (temp1)
42921 delete arg1;
42922 }
42923 return resultobj;
42924 fail:
42925 {
42926 if (temp1)
42927 delete arg1;
42928 }
42929 return NULL;
42930 }
42931
42932
42933 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42934 PyObject *resultobj = 0;
42935 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42936 wxItemKind result;
42937 void *argp1 = 0 ;
42938 int res1 = 0 ;
42939 PyObject *swig_obj[1] ;
42940
42941 if (!args) SWIG_fail;
42942 swig_obj[0] = args;
42943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42944 if (!SWIG_IsOK(res1)) {
42945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42946 }
42947 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42948 {
42949 PyThreadState* __tstate = wxPyBeginAllowThreads();
42950 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42951 wxPyEndAllowThreads(__tstate);
42952 if (PyErr_Occurred()) SWIG_fail;
42953 }
42954 resultobj = SWIG_From_int(static_cast< int >(result));
42955 return resultobj;
42956 fail:
42957 return NULL;
42958 }
42959
42960
42961 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42962 PyObject *resultobj = 0;
42963 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42964 wxItemKind arg2 ;
42965 void *argp1 = 0 ;
42966 int res1 = 0 ;
42967 int val2 ;
42968 int ecode2 = 0 ;
42969 PyObject * obj0 = 0 ;
42970 PyObject * obj1 = 0 ;
42971 char * kwnames[] = {
42972 (char *) "self",(char *) "kind", NULL
42973 };
42974
42975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42977 if (!SWIG_IsOK(res1)) {
42978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42979 }
42980 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42981 ecode2 = SWIG_AsVal_int(obj1, &val2);
42982 if (!SWIG_IsOK(ecode2)) {
42983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42984 }
42985 arg2 = static_cast< wxItemKind >(val2);
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 (arg1)->SetKind(arg2);
42989 wxPyEndAllowThreads(__tstate);
42990 if (PyErr_Occurred()) SWIG_fail;
42991 }
42992 resultobj = SWIG_Py_Void();
42993 return resultobj;
42994 fail:
42995 return NULL;
42996 }
42997
42998
42999 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43000 PyObject *resultobj = 0;
43001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43002 bool arg2 ;
43003 void *argp1 = 0 ;
43004 int res1 = 0 ;
43005 bool val2 ;
43006 int ecode2 = 0 ;
43007 PyObject * obj0 = 0 ;
43008 PyObject * obj1 = 0 ;
43009 char * kwnames[] = {
43010 (char *) "self",(char *) "checkable", NULL
43011 };
43012
43013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43015 if (!SWIG_IsOK(res1)) {
43016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43017 }
43018 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43019 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43020 if (!SWIG_IsOK(ecode2)) {
43021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43022 }
43023 arg2 = static_cast< bool >(val2);
43024 {
43025 PyThreadState* __tstate = wxPyBeginAllowThreads();
43026 (arg1)->SetCheckable(arg2);
43027 wxPyEndAllowThreads(__tstate);
43028 if (PyErr_Occurred()) SWIG_fail;
43029 }
43030 resultobj = SWIG_Py_Void();
43031 return resultobj;
43032 fail:
43033 return NULL;
43034 }
43035
43036
43037 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43038 PyObject *resultobj = 0;
43039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43040 bool result;
43041 void *argp1 = 0 ;
43042 int res1 = 0 ;
43043 PyObject *swig_obj[1] ;
43044
43045 if (!args) SWIG_fail;
43046 swig_obj[0] = args;
43047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43048 if (!SWIG_IsOK(res1)) {
43049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43050 }
43051 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43052 {
43053 PyThreadState* __tstate = wxPyBeginAllowThreads();
43054 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43055 wxPyEndAllowThreads(__tstate);
43056 if (PyErr_Occurred()) SWIG_fail;
43057 }
43058 {
43059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43060 }
43061 return resultobj;
43062 fail:
43063 return NULL;
43064 }
43065
43066
43067 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43068 PyObject *resultobj = 0;
43069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43070 bool result;
43071 void *argp1 = 0 ;
43072 int res1 = 0 ;
43073 PyObject *swig_obj[1] ;
43074
43075 if (!args) SWIG_fail;
43076 swig_obj[0] = args;
43077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43078 if (!SWIG_IsOK(res1)) {
43079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43080 }
43081 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43082 {
43083 PyThreadState* __tstate = wxPyBeginAllowThreads();
43084 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43085 wxPyEndAllowThreads(__tstate);
43086 if (PyErr_Occurred()) SWIG_fail;
43087 }
43088 {
43089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43090 }
43091 return resultobj;
43092 fail:
43093 return NULL;
43094 }
43095
43096
43097 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43098 PyObject *resultobj = 0;
43099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43100 wxMenu *arg2 = (wxMenu *) 0 ;
43101 void *argp1 = 0 ;
43102 int res1 = 0 ;
43103 void *argp2 = 0 ;
43104 int res2 = 0 ;
43105 PyObject * obj0 = 0 ;
43106 PyObject * obj1 = 0 ;
43107 char * kwnames[] = {
43108 (char *) "self",(char *) "menu", NULL
43109 };
43110
43111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43113 if (!SWIG_IsOK(res1)) {
43114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43115 }
43116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43118 if (!SWIG_IsOK(res2)) {
43119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43120 }
43121 arg2 = reinterpret_cast< wxMenu * >(argp2);
43122 {
43123 PyThreadState* __tstate = wxPyBeginAllowThreads();
43124 (arg1)->SetSubMenu(arg2);
43125 wxPyEndAllowThreads(__tstate);
43126 if (PyErr_Occurred()) SWIG_fail;
43127 }
43128 resultobj = SWIG_Py_Void();
43129 return resultobj;
43130 fail:
43131 return NULL;
43132 }
43133
43134
43135 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43136 PyObject *resultobj = 0;
43137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43138 wxMenu *result = 0 ;
43139 void *argp1 = 0 ;
43140 int res1 = 0 ;
43141 PyObject *swig_obj[1] ;
43142
43143 if (!args) SWIG_fail;
43144 swig_obj[0] = args;
43145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43146 if (!SWIG_IsOK(res1)) {
43147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43148 }
43149 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43150 {
43151 PyThreadState* __tstate = wxPyBeginAllowThreads();
43152 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43153 wxPyEndAllowThreads(__tstate);
43154 if (PyErr_Occurred()) SWIG_fail;
43155 }
43156 {
43157 resultobj = wxPyMake_wxObject(result, 0);
43158 }
43159 return resultobj;
43160 fail:
43161 return NULL;
43162 }
43163
43164
43165 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43166 PyObject *resultobj = 0;
43167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43168 bool arg2 = (bool) true ;
43169 void *argp1 = 0 ;
43170 int res1 = 0 ;
43171 bool val2 ;
43172 int ecode2 = 0 ;
43173 PyObject * obj0 = 0 ;
43174 PyObject * obj1 = 0 ;
43175 char * kwnames[] = {
43176 (char *) "self",(char *) "enable", NULL
43177 };
43178
43179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43181 if (!SWIG_IsOK(res1)) {
43182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43183 }
43184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43185 if (obj1) {
43186 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43187 if (!SWIG_IsOK(ecode2)) {
43188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43189 }
43190 arg2 = static_cast< bool >(val2);
43191 }
43192 {
43193 PyThreadState* __tstate = wxPyBeginAllowThreads();
43194 (arg1)->Enable(arg2);
43195 wxPyEndAllowThreads(__tstate);
43196 if (PyErr_Occurred()) SWIG_fail;
43197 }
43198 resultobj = SWIG_Py_Void();
43199 return resultobj;
43200 fail:
43201 return NULL;
43202 }
43203
43204
43205 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43206 PyObject *resultobj = 0;
43207 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43208 bool result;
43209 void *argp1 = 0 ;
43210 int res1 = 0 ;
43211 PyObject *swig_obj[1] ;
43212
43213 if (!args) SWIG_fail;
43214 swig_obj[0] = args;
43215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43220 {
43221 PyThreadState* __tstate = wxPyBeginAllowThreads();
43222 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43223 wxPyEndAllowThreads(__tstate);
43224 if (PyErr_Occurred()) SWIG_fail;
43225 }
43226 {
43227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43228 }
43229 return resultobj;
43230 fail:
43231 return NULL;
43232 }
43233
43234
43235 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43236 PyObject *resultobj = 0;
43237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43238 bool arg2 = (bool) true ;
43239 void *argp1 = 0 ;
43240 int res1 = 0 ;
43241 bool val2 ;
43242 int ecode2 = 0 ;
43243 PyObject * obj0 = 0 ;
43244 PyObject * obj1 = 0 ;
43245 char * kwnames[] = {
43246 (char *) "self",(char *) "check", NULL
43247 };
43248
43249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43251 if (!SWIG_IsOK(res1)) {
43252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43253 }
43254 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43255 if (obj1) {
43256 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43257 if (!SWIG_IsOK(ecode2)) {
43258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43259 }
43260 arg2 = static_cast< bool >(val2);
43261 }
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 (arg1)->Check(arg2);
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 resultobj = SWIG_Py_Void();
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43276 PyObject *resultobj = 0;
43277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43278 bool result;
43279 void *argp1 = 0 ;
43280 int res1 = 0 ;
43281 PyObject *swig_obj[1] ;
43282
43283 if (!args) SWIG_fail;
43284 swig_obj[0] = args;
43285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43286 if (!SWIG_IsOK(res1)) {
43287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43288 }
43289 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43290 {
43291 PyThreadState* __tstate = wxPyBeginAllowThreads();
43292 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43293 wxPyEndAllowThreads(__tstate);
43294 if (PyErr_Occurred()) SWIG_fail;
43295 }
43296 {
43297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43298 }
43299 return resultobj;
43300 fail:
43301 return NULL;
43302 }
43303
43304
43305 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43306 PyObject *resultobj = 0;
43307 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43308 void *argp1 = 0 ;
43309 int res1 = 0 ;
43310 PyObject *swig_obj[1] ;
43311
43312 if (!args) SWIG_fail;
43313 swig_obj[0] = args;
43314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43315 if (!SWIG_IsOK(res1)) {
43316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43317 }
43318 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43319 {
43320 PyThreadState* __tstate = wxPyBeginAllowThreads();
43321 (arg1)->Toggle();
43322 wxPyEndAllowThreads(__tstate);
43323 if (PyErr_Occurred()) SWIG_fail;
43324 }
43325 resultobj = SWIG_Py_Void();
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj = 0;
43334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43335 wxString *arg2 = 0 ;
43336 void *argp1 = 0 ;
43337 int res1 = 0 ;
43338 bool temp2 = false ;
43339 PyObject * obj0 = 0 ;
43340 PyObject * obj1 = 0 ;
43341 char * kwnames[] = {
43342 (char *) "self",(char *) "str", NULL
43343 };
43344
43345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43347 if (!SWIG_IsOK(res1)) {
43348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43349 }
43350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43351 {
43352 arg2 = wxString_in_helper(obj1);
43353 if (arg2 == NULL) SWIG_fail;
43354 temp2 = true;
43355 }
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 (arg1)->SetHelp((wxString const &)*arg2);
43359 wxPyEndAllowThreads(__tstate);
43360 if (PyErr_Occurred()) SWIG_fail;
43361 }
43362 resultobj = SWIG_Py_Void();
43363 {
43364 if (temp2)
43365 delete arg2;
43366 }
43367 return resultobj;
43368 fail:
43369 {
43370 if (temp2)
43371 delete arg2;
43372 }
43373 return NULL;
43374 }
43375
43376
43377 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43378 PyObject *resultobj = 0;
43379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43380 wxString *result = 0 ;
43381 void *argp1 = 0 ;
43382 int res1 = 0 ;
43383 PyObject *swig_obj[1] ;
43384
43385 if (!args) SWIG_fail;
43386 swig_obj[0] = args;
43387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43388 if (!SWIG_IsOK(res1)) {
43389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43390 }
43391 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 {
43395 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43396 result = (wxString *) &_result_ref;
43397 }
43398 wxPyEndAllowThreads(__tstate);
43399 if (PyErr_Occurred()) SWIG_fail;
43400 }
43401 {
43402 #if wxUSE_UNICODE
43403 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43404 #else
43405 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43406 #endif
43407 }
43408 return resultobj;
43409 fail:
43410 return NULL;
43411 }
43412
43413
43414 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43415 PyObject *resultobj = 0;
43416 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43417 wxAcceleratorEntry *result = 0 ;
43418 void *argp1 = 0 ;
43419 int res1 = 0 ;
43420 PyObject *swig_obj[1] ;
43421
43422 if (!args) SWIG_fail;
43423 swig_obj[0] = args;
43424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43425 if (!SWIG_IsOK(res1)) {
43426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43427 }
43428 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43429 {
43430 PyThreadState* __tstate = wxPyBeginAllowThreads();
43431 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43436 return resultobj;
43437 fail:
43438 return NULL;
43439 }
43440
43441
43442 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43443 PyObject *resultobj = 0;
43444 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43445 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43446 void *argp1 = 0 ;
43447 int res1 = 0 ;
43448 void *argp2 = 0 ;
43449 int res2 = 0 ;
43450 PyObject * obj0 = 0 ;
43451 PyObject * obj1 = 0 ;
43452 char * kwnames[] = {
43453 (char *) "self",(char *) "accel", NULL
43454 };
43455
43456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43458 if (!SWIG_IsOK(res1)) {
43459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43460 }
43461 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43463 if (!SWIG_IsOK(res2)) {
43464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43465 }
43466 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43467 {
43468 PyThreadState* __tstate = wxPyBeginAllowThreads();
43469 (arg1)->SetAccel(arg2);
43470 wxPyEndAllowThreads(__tstate);
43471 if (PyErr_Occurred()) SWIG_fail;
43472 }
43473 resultobj = SWIG_Py_Void();
43474 return resultobj;
43475 fail:
43476 return NULL;
43477 }
43478
43479
43480 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43481 PyObject *resultobj = 0;
43482 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43483 wxBitmap *arg2 = 0 ;
43484 void *argp1 = 0 ;
43485 int res1 = 0 ;
43486 void *argp2 = 0 ;
43487 int res2 = 0 ;
43488 PyObject * obj0 = 0 ;
43489 PyObject * obj1 = 0 ;
43490 char * kwnames[] = {
43491 (char *) "self",(char *) "bitmap", NULL
43492 };
43493
43494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43496 if (!SWIG_IsOK(res1)) {
43497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43498 }
43499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43500 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43501 if (!SWIG_IsOK(res2)) {
43502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43503 }
43504 if (!argp2) {
43505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43506 }
43507 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43508 {
43509 PyThreadState* __tstate = wxPyBeginAllowThreads();
43510 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43511 wxPyEndAllowThreads(__tstate);
43512 if (PyErr_Occurred()) SWIG_fail;
43513 }
43514 resultobj = SWIG_Py_Void();
43515 return resultobj;
43516 fail:
43517 return NULL;
43518 }
43519
43520
43521 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43522 PyObject *resultobj = 0;
43523 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43524 wxBitmap *result = 0 ;
43525 void *argp1 = 0 ;
43526 int res1 = 0 ;
43527 PyObject *swig_obj[1] ;
43528
43529 if (!args) SWIG_fail;
43530 swig_obj[0] = args;
43531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43532 if (!SWIG_IsOK(res1)) {
43533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43534 }
43535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43536 {
43537 PyThreadState* __tstate = wxPyBeginAllowThreads();
43538 {
43539 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43540 result = (wxBitmap *) &_result_ref;
43541 }
43542 wxPyEndAllowThreads(__tstate);
43543 if (PyErr_Occurred()) SWIG_fail;
43544 }
43545 {
43546 wxBitmap* resultptr = new wxBitmap(*result);
43547 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43548 }
43549 return resultobj;
43550 fail:
43551 return NULL;
43552 }
43553
43554
43555 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43556 PyObject *resultobj = 0;
43557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43558 wxFont *arg2 = 0 ;
43559 void *argp1 = 0 ;
43560 int res1 = 0 ;
43561 void *argp2 = 0 ;
43562 int res2 = 0 ;
43563 PyObject * obj0 = 0 ;
43564 PyObject * obj1 = 0 ;
43565 char * kwnames[] = {
43566 (char *) "self",(char *) "font", NULL
43567 };
43568
43569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43571 if (!SWIG_IsOK(res1)) {
43572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43573 }
43574 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43575 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43576 if (!SWIG_IsOK(res2)) {
43577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43578 }
43579 if (!argp2) {
43580 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43581 }
43582 arg2 = reinterpret_cast< wxFont * >(argp2);
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 (arg1)->SetFont((wxFont const &)*arg2);
43586 wxPyEndAllowThreads(__tstate);
43587 if (PyErr_Occurred()) SWIG_fail;
43588 }
43589 resultobj = SWIG_Py_Void();
43590 return resultobj;
43591 fail:
43592 return NULL;
43593 }
43594
43595
43596 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43597 PyObject *resultobj = 0;
43598 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43599 wxFont result;
43600 void *argp1 = 0 ;
43601 int res1 = 0 ;
43602 PyObject *swig_obj[1] ;
43603
43604 if (!args) SWIG_fail;
43605 swig_obj[0] = args;
43606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43607 if (!SWIG_IsOK(res1)) {
43608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43609 }
43610 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43611 {
43612 PyThreadState* __tstate = wxPyBeginAllowThreads();
43613 result = (arg1)->GetFont();
43614 wxPyEndAllowThreads(__tstate);
43615 if (PyErr_Occurred()) SWIG_fail;
43616 }
43617 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43618 return resultobj;
43619 fail:
43620 return NULL;
43621 }
43622
43623
43624 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43625 PyObject *resultobj = 0;
43626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43627 wxColour *arg2 = 0 ;
43628 void *argp1 = 0 ;
43629 int res1 = 0 ;
43630 wxColour temp2 ;
43631 PyObject * obj0 = 0 ;
43632 PyObject * obj1 = 0 ;
43633 char * kwnames[] = {
43634 (char *) "self",(char *) "colText", NULL
43635 };
43636
43637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43639 if (!SWIG_IsOK(res1)) {
43640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43641 }
43642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43643 {
43644 arg2 = &temp2;
43645 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43646 }
43647 {
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 (arg1)->SetTextColour((wxColour const &)*arg2);
43650 wxPyEndAllowThreads(__tstate);
43651 if (PyErr_Occurred()) SWIG_fail;
43652 }
43653 resultobj = SWIG_Py_Void();
43654 return resultobj;
43655 fail:
43656 return NULL;
43657 }
43658
43659
43660 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43661 PyObject *resultobj = 0;
43662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43663 wxColour result;
43664 void *argp1 = 0 ;
43665 int res1 = 0 ;
43666 PyObject *swig_obj[1] ;
43667
43668 if (!args) SWIG_fail;
43669 swig_obj[0] = args;
43670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43671 if (!SWIG_IsOK(res1)) {
43672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43673 }
43674 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43675 {
43676 PyThreadState* __tstate = wxPyBeginAllowThreads();
43677 result = (arg1)->GetTextColour();
43678 wxPyEndAllowThreads(__tstate);
43679 if (PyErr_Occurred()) SWIG_fail;
43680 }
43681 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43682 return resultobj;
43683 fail:
43684 return NULL;
43685 }
43686
43687
43688 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43689 PyObject *resultobj = 0;
43690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43691 wxColour *arg2 = 0 ;
43692 void *argp1 = 0 ;
43693 int res1 = 0 ;
43694 wxColour temp2 ;
43695 PyObject * obj0 = 0 ;
43696 PyObject * obj1 = 0 ;
43697 char * kwnames[] = {
43698 (char *) "self",(char *) "colBack", NULL
43699 };
43700
43701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43703 if (!SWIG_IsOK(res1)) {
43704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43705 }
43706 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43707 {
43708 arg2 = &temp2;
43709 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43710 }
43711 {
43712 PyThreadState* __tstate = wxPyBeginAllowThreads();
43713 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43714 wxPyEndAllowThreads(__tstate);
43715 if (PyErr_Occurred()) SWIG_fail;
43716 }
43717 resultobj = SWIG_Py_Void();
43718 return resultobj;
43719 fail:
43720 return NULL;
43721 }
43722
43723
43724 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43725 PyObject *resultobj = 0;
43726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43727 wxColour result;
43728 void *argp1 = 0 ;
43729 int res1 = 0 ;
43730 PyObject *swig_obj[1] ;
43731
43732 if (!args) SWIG_fail;
43733 swig_obj[0] = args;
43734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43735 if (!SWIG_IsOK(res1)) {
43736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43737 }
43738 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 result = (arg1)->GetBackgroundColour();
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43746 return resultobj;
43747 fail:
43748 return NULL;
43749 }
43750
43751
43752 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43753 PyObject *resultobj = 0;
43754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43755 wxBitmap *arg2 = 0 ;
43756 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43757 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43758 void *argp1 = 0 ;
43759 int res1 = 0 ;
43760 void *argp2 = 0 ;
43761 int res2 = 0 ;
43762 void *argp3 = 0 ;
43763 int res3 = 0 ;
43764 PyObject * obj0 = 0 ;
43765 PyObject * obj1 = 0 ;
43766 PyObject * obj2 = 0 ;
43767 char * kwnames[] = {
43768 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43769 };
43770
43771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43773 if (!SWIG_IsOK(res1)) {
43774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43775 }
43776 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43777 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43778 if (!SWIG_IsOK(res2)) {
43779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43780 }
43781 if (!argp2) {
43782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43783 }
43784 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43785 if (obj2) {
43786 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43787 if (!SWIG_IsOK(res3)) {
43788 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43789 }
43790 if (!argp3) {
43791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43792 }
43793 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43794 }
43795 {
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43798 wxPyEndAllowThreads(__tstate);
43799 if (PyErr_Occurred()) SWIG_fail;
43800 }
43801 resultobj = SWIG_Py_Void();
43802 return resultobj;
43803 fail:
43804 return NULL;
43805 }
43806
43807
43808 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43809 PyObject *resultobj = 0;
43810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43811 wxBitmap *arg2 = 0 ;
43812 void *argp1 = 0 ;
43813 int res1 = 0 ;
43814 void *argp2 = 0 ;
43815 int res2 = 0 ;
43816 PyObject * obj0 = 0 ;
43817 PyObject * obj1 = 0 ;
43818 char * kwnames[] = {
43819 (char *) "self",(char *) "bmpDisabled", NULL
43820 };
43821
43822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43824 if (!SWIG_IsOK(res1)) {
43825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43826 }
43827 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43829 if (!SWIG_IsOK(res2)) {
43830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43831 }
43832 if (!argp2) {
43833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43834 }
43835 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43836 {
43837 PyThreadState* __tstate = wxPyBeginAllowThreads();
43838 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43839 wxPyEndAllowThreads(__tstate);
43840 if (PyErr_Occurred()) SWIG_fail;
43841 }
43842 resultobj = SWIG_Py_Void();
43843 return resultobj;
43844 fail:
43845 return NULL;
43846 }
43847
43848
43849 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43850 PyObject *resultobj = 0;
43851 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43852 wxBitmap *result = 0 ;
43853 void *argp1 = 0 ;
43854 int res1 = 0 ;
43855 PyObject *swig_obj[1] ;
43856
43857 if (!args) SWIG_fail;
43858 swig_obj[0] = args;
43859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43860 if (!SWIG_IsOK(res1)) {
43861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43862 }
43863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43864 {
43865 PyThreadState* __tstate = wxPyBeginAllowThreads();
43866 {
43867 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43868 result = (wxBitmap *) &_result_ref;
43869 }
43870 wxPyEndAllowThreads(__tstate);
43871 if (PyErr_Occurred()) SWIG_fail;
43872 }
43873 {
43874 wxBitmap* resultptr = new wxBitmap(*result);
43875 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43876 }
43877 return resultobj;
43878 fail:
43879 return NULL;
43880 }
43881
43882
43883 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43884 PyObject *resultobj = 0;
43885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43886 int arg2 ;
43887 void *argp1 = 0 ;
43888 int res1 = 0 ;
43889 int val2 ;
43890 int ecode2 = 0 ;
43891 PyObject * obj0 = 0 ;
43892 PyObject * obj1 = 0 ;
43893 char * kwnames[] = {
43894 (char *) "self",(char *) "nWidth", NULL
43895 };
43896
43897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43899 if (!SWIG_IsOK(res1)) {
43900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43901 }
43902 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43903 ecode2 = SWIG_AsVal_int(obj1, &val2);
43904 if (!SWIG_IsOK(ecode2)) {
43905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43906 }
43907 arg2 = static_cast< int >(val2);
43908 {
43909 PyThreadState* __tstate = wxPyBeginAllowThreads();
43910 (arg1)->SetMarginWidth(arg2);
43911 wxPyEndAllowThreads(__tstate);
43912 if (PyErr_Occurred()) SWIG_fail;
43913 }
43914 resultobj = SWIG_Py_Void();
43915 return resultobj;
43916 fail:
43917 return NULL;
43918 }
43919
43920
43921 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43922 PyObject *resultobj = 0;
43923 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43924 int result;
43925 void *argp1 = 0 ;
43926 int res1 = 0 ;
43927 PyObject *swig_obj[1] ;
43928
43929 if (!args) SWIG_fail;
43930 swig_obj[0] = args;
43931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43932 if (!SWIG_IsOK(res1)) {
43933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43934 }
43935 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43936 {
43937 PyThreadState* __tstate = wxPyBeginAllowThreads();
43938 result = (int)(arg1)->GetMarginWidth();
43939 wxPyEndAllowThreads(__tstate);
43940 if (PyErr_Occurred()) SWIG_fail;
43941 }
43942 resultobj = SWIG_From_int(static_cast< int >(result));
43943 return resultobj;
43944 fail:
43945 return NULL;
43946 }
43947
43948
43949 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43950 PyObject *resultobj = 0;
43951 int result;
43952
43953 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 result = (int)wxMenuItem::GetDefaultMarginWidth();
43957 wxPyEndAllowThreads(__tstate);
43958 if (PyErr_Occurred()) SWIG_fail;
43959 }
43960 resultobj = SWIG_From_int(static_cast< int >(result));
43961 return resultobj;
43962 fail:
43963 return NULL;
43964 }
43965
43966
43967 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43968 PyObject *resultobj = 0;
43969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43970 bool result;
43971 void *argp1 = 0 ;
43972 int res1 = 0 ;
43973 PyObject *swig_obj[1] ;
43974
43975 if (!args) SWIG_fail;
43976 swig_obj[0] = args;
43977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43978 if (!SWIG_IsOK(res1)) {
43979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43980 }
43981 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43982 {
43983 PyThreadState* __tstate = wxPyBeginAllowThreads();
43984 result = (bool)(arg1)->IsOwnerDrawn();
43985 wxPyEndAllowThreads(__tstate);
43986 if (PyErr_Occurred()) SWIG_fail;
43987 }
43988 {
43989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43990 }
43991 return resultobj;
43992 fail:
43993 return NULL;
43994 }
43995
43996
43997 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43998 PyObject *resultobj = 0;
43999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44000 bool arg2 = (bool) true ;
44001 void *argp1 = 0 ;
44002 int res1 = 0 ;
44003 bool val2 ;
44004 int ecode2 = 0 ;
44005 PyObject * obj0 = 0 ;
44006 PyObject * obj1 = 0 ;
44007 char * kwnames[] = {
44008 (char *) "self",(char *) "ownerDrawn", NULL
44009 };
44010
44011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44013 if (!SWIG_IsOK(res1)) {
44014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44015 }
44016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44017 if (obj1) {
44018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44019 if (!SWIG_IsOK(ecode2)) {
44020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44021 }
44022 arg2 = static_cast< bool >(val2);
44023 }
44024 {
44025 PyThreadState* __tstate = wxPyBeginAllowThreads();
44026 (arg1)->SetOwnerDrawn(arg2);
44027 wxPyEndAllowThreads(__tstate);
44028 if (PyErr_Occurred()) SWIG_fail;
44029 }
44030 resultobj = SWIG_Py_Void();
44031 return resultobj;
44032 fail:
44033 return NULL;
44034 }
44035
44036
44037 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44038 PyObject *resultobj = 0;
44039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44040 void *argp1 = 0 ;
44041 int res1 = 0 ;
44042 PyObject *swig_obj[1] ;
44043
44044 if (!args) SWIG_fail;
44045 swig_obj[0] = args;
44046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44047 if (!SWIG_IsOK(res1)) {
44048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44049 }
44050 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44051 {
44052 PyThreadState* __tstate = wxPyBeginAllowThreads();
44053 (arg1)->ResetOwnerDrawn();
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 resultobj = SWIG_Py_Void();
44058 return resultobj;
44059 fail:
44060 return NULL;
44061 }
44062
44063
44064 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44065 PyObject *obj;
44066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44067 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44068 return SWIG_Py_Void();
44069 }
44070
44071 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44072 return SWIG_Python_InitShadowInstance(args);
44073 }
44074
44075 SWIGINTERN int ControlNameStr_set(PyObject *) {
44076 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44077 return 1;
44078 }
44079
44080
44081 SWIGINTERN PyObject *ControlNameStr_get(void) {
44082 PyObject *pyobj = 0;
44083
44084 {
44085 #if wxUSE_UNICODE
44086 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44087 #else
44088 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44089 #endif
44090 }
44091 return pyobj;
44092 }
44093
44094
44095 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44096 PyObject *resultobj = 0;
44097 wxWindow *arg1 = (wxWindow *) 0 ;
44098 int arg2 = (int) -1 ;
44099 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44100 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44101 wxSize const &arg4_defvalue = wxDefaultSize ;
44102 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44103 long arg5 = (long) 0 ;
44104 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44105 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44106 wxString const &arg7_defvalue = wxPyControlNameStr ;
44107 wxString *arg7 = (wxString *) &arg7_defvalue ;
44108 wxControl *result = 0 ;
44109 void *argp1 = 0 ;
44110 int res1 = 0 ;
44111 int val2 ;
44112 int ecode2 = 0 ;
44113 wxPoint temp3 ;
44114 wxSize temp4 ;
44115 long val5 ;
44116 int ecode5 = 0 ;
44117 void *argp6 = 0 ;
44118 int res6 = 0 ;
44119 bool temp7 = false ;
44120 PyObject * obj0 = 0 ;
44121 PyObject * obj1 = 0 ;
44122 PyObject * obj2 = 0 ;
44123 PyObject * obj3 = 0 ;
44124 PyObject * obj4 = 0 ;
44125 PyObject * obj5 = 0 ;
44126 PyObject * obj6 = 0 ;
44127 char * kwnames[] = {
44128 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44129 };
44130
44131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44135 }
44136 arg1 = reinterpret_cast< wxWindow * >(argp1);
44137 if (obj1) {
44138 ecode2 = SWIG_AsVal_int(obj1, &val2);
44139 if (!SWIG_IsOK(ecode2)) {
44140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44141 }
44142 arg2 = static_cast< int >(val2);
44143 }
44144 if (obj2) {
44145 {
44146 arg3 = &temp3;
44147 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44148 }
44149 }
44150 if (obj3) {
44151 {
44152 arg4 = &temp4;
44153 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44154 }
44155 }
44156 if (obj4) {
44157 ecode5 = SWIG_AsVal_long(obj4, &val5);
44158 if (!SWIG_IsOK(ecode5)) {
44159 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44160 }
44161 arg5 = static_cast< long >(val5);
44162 }
44163 if (obj5) {
44164 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44165 if (!SWIG_IsOK(res6)) {
44166 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44167 }
44168 if (!argp6) {
44169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44170 }
44171 arg6 = reinterpret_cast< wxValidator * >(argp6);
44172 }
44173 if (obj6) {
44174 {
44175 arg7 = wxString_in_helper(obj6);
44176 if (arg7 == NULL) SWIG_fail;
44177 temp7 = true;
44178 }
44179 }
44180 {
44181 if (!wxPyCheckForApp()) SWIG_fail;
44182 PyThreadState* __tstate = wxPyBeginAllowThreads();
44183 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44184 wxPyEndAllowThreads(__tstate);
44185 if (PyErr_Occurred()) SWIG_fail;
44186 }
44187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44188 {
44189 if (temp7)
44190 delete arg7;
44191 }
44192 return resultobj;
44193 fail:
44194 {
44195 if (temp7)
44196 delete arg7;
44197 }
44198 return NULL;
44199 }
44200
44201
44202 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44203 PyObject *resultobj = 0;
44204 wxControl *result = 0 ;
44205
44206 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44207 {
44208 if (!wxPyCheckForApp()) SWIG_fail;
44209 PyThreadState* __tstate = wxPyBeginAllowThreads();
44210 result = (wxControl *)new wxControl();
44211 wxPyEndAllowThreads(__tstate);
44212 if (PyErr_Occurred()) SWIG_fail;
44213 }
44214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44215 return resultobj;
44216 fail:
44217 return NULL;
44218 }
44219
44220
44221 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44222 PyObject *resultobj = 0;
44223 wxControl *arg1 = (wxControl *) 0 ;
44224 wxWindow *arg2 = (wxWindow *) 0 ;
44225 int arg3 = (int) -1 ;
44226 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44227 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44228 wxSize const &arg5_defvalue = wxDefaultSize ;
44229 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44230 long arg6 = (long) 0 ;
44231 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44232 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44233 wxString const &arg8_defvalue = wxPyControlNameStr ;
44234 wxString *arg8 = (wxString *) &arg8_defvalue ;
44235 bool result;
44236 void *argp1 = 0 ;
44237 int res1 = 0 ;
44238 void *argp2 = 0 ;
44239 int res2 = 0 ;
44240 int val3 ;
44241 int ecode3 = 0 ;
44242 wxPoint temp4 ;
44243 wxSize temp5 ;
44244 long val6 ;
44245 int ecode6 = 0 ;
44246 void *argp7 = 0 ;
44247 int res7 = 0 ;
44248 bool temp8 = false ;
44249 PyObject * obj0 = 0 ;
44250 PyObject * obj1 = 0 ;
44251 PyObject * obj2 = 0 ;
44252 PyObject * obj3 = 0 ;
44253 PyObject * obj4 = 0 ;
44254 PyObject * obj5 = 0 ;
44255 PyObject * obj6 = 0 ;
44256 PyObject * obj7 = 0 ;
44257 char * kwnames[] = {
44258 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44259 };
44260
44261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44263 if (!SWIG_IsOK(res1)) {
44264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44265 }
44266 arg1 = reinterpret_cast< wxControl * >(argp1);
44267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44268 if (!SWIG_IsOK(res2)) {
44269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44270 }
44271 arg2 = reinterpret_cast< wxWindow * >(argp2);
44272 if (obj2) {
44273 ecode3 = SWIG_AsVal_int(obj2, &val3);
44274 if (!SWIG_IsOK(ecode3)) {
44275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44276 }
44277 arg3 = static_cast< int >(val3);
44278 }
44279 if (obj3) {
44280 {
44281 arg4 = &temp4;
44282 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44283 }
44284 }
44285 if (obj4) {
44286 {
44287 arg5 = &temp5;
44288 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44289 }
44290 }
44291 if (obj5) {
44292 ecode6 = SWIG_AsVal_long(obj5, &val6);
44293 if (!SWIG_IsOK(ecode6)) {
44294 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44295 }
44296 arg6 = static_cast< long >(val6);
44297 }
44298 if (obj6) {
44299 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44300 if (!SWIG_IsOK(res7)) {
44301 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44302 }
44303 if (!argp7) {
44304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44305 }
44306 arg7 = reinterpret_cast< wxValidator * >(argp7);
44307 }
44308 if (obj7) {
44309 {
44310 arg8 = wxString_in_helper(obj7);
44311 if (arg8 == NULL) SWIG_fail;
44312 temp8 = true;
44313 }
44314 }
44315 {
44316 PyThreadState* __tstate = wxPyBeginAllowThreads();
44317 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44318 wxPyEndAllowThreads(__tstate);
44319 if (PyErr_Occurred()) SWIG_fail;
44320 }
44321 {
44322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44323 }
44324 {
44325 if (temp8)
44326 delete arg8;
44327 }
44328 return resultobj;
44329 fail:
44330 {
44331 if (temp8)
44332 delete arg8;
44333 }
44334 return NULL;
44335 }
44336
44337
44338 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44339 PyObject *resultobj = 0;
44340 wxControl *arg1 = (wxControl *) 0 ;
44341 int result;
44342 void *argp1 = 0 ;
44343 int res1 = 0 ;
44344 PyObject *swig_obj[1] ;
44345
44346 if (!args) SWIG_fail;
44347 swig_obj[0] = args;
44348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44349 if (!SWIG_IsOK(res1)) {
44350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44351 }
44352 arg1 = reinterpret_cast< wxControl * >(argp1);
44353 {
44354 PyThreadState* __tstate = wxPyBeginAllowThreads();
44355 result = (int)((wxControl const *)arg1)->GetAlignment();
44356 wxPyEndAllowThreads(__tstate);
44357 if (PyErr_Occurred()) SWIG_fail;
44358 }
44359 resultobj = SWIG_From_int(static_cast< int >(result));
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44367 PyObject *resultobj = 0;
44368 wxControl *arg1 = (wxControl *) 0 ;
44369 wxString result;
44370 void *argp1 = 0 ;
44371 int res1 = 0 ;
44372 PyObject *swig_obj[1] ;
44373
44374 if (!args) SWIG_fail;
44375 swig_obj[0] = args;
44376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44377 if (!SWIG_IsOK(res1)) {
44378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44379 }
44380 arg1 = reinterpret_cast< wxControl * >(argp1);
44381 {
44382 PyThreadState* __tstate = wxPyBeginAllowThreads();
44383 result = ((wxControl const *)arg1)->GetLabelText();
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 {
44388 #if wxUSE_UNICODE
44389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44390 #else
44391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44392 #endif
44393 }
44394 return resultobj;
44395 fail:
44396 return NULL;
44397 }
44398
44399
44400 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44401 PyObject *resultobj = 0;
44402 wxControl *arg1 = (wxControl *) 0 ;
44403 wxCommandEvent *arg2 = 0 ;
44404 void *argp1 = 0 ;
44405 int res1 = 0 ;
44406 void *argp2 = 0 ;
44407 int res2 = 0 ;
44408 PyObject * obj0 = 0 ;
44409 PyObject * obj1 = 0 ;
44410 char * kwnames[] = {
44411 (char *) "self",(char *) "event", NULL
44412 };
44413
44414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44416 if (!SWIG_IsOK(res1)) {
44417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44418 }
44419 arg1 = reinterpret_cast< wxControl * >(argp1);
44420 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44421 if (!SWIG_IsOK(res2)) {
44422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44423 }
44424 if (!argp2) {
44425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44426 }
44427 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 (arg1)->Command(*arg2);
44431 wxPyEndAllowThreads(__tstate);
44432 if (PyErr_Occurred()) SWIG_fail;
44433 }
44434 resultobj = SWIG_Py_Void();
44435 return resultobj;
44436 fail:
44437 return NULL;
44438 }
44439
44440
44441 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44442 PyObject *resultobj = 0;
44443 wxControl *arg1 = (wxControl *) 0 ;
44444 wxString result;
44445 void *argp1 = 0 ;
44446 int res1 = 0 ;
44447 PyObject *swig_obj[1] ;
44448
44449 if (!args) SWIG_fail;
44450 swig_obj[0] = args;
44451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44452 if (!SWIG_IsOK(res1)) {
44453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44454 }
44455 arg1 = reinterpret_cast< wxControl * >(argp1);
44456 {
44457 PyThreadState* __tstate = wxPyBeginAllowThreads();
44458 result = (arg1)->GetLabel();
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 {
44463 #if wxUSE_UNICODE
44464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44465 #else
44466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44467 #endif
44468 }
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44476 PyObject *resultobj = 0;
44477 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44478 SwigValueWrapper<wxVisualAttributes > result;
44479 int val1 ;
44480 int ecode1 = 0 ;
44481 PyObject * obj0 = 0 ;
44482 char * kwnames[] = {
44483 (char *) "variant", NULL
44484 };
44485
44486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44487 if (obj0) {
44488 ecode1 = SWIG_AsVal_int(obj0, &val1);
44489 if (!SWIG_IsOK(ecode1)) {
44490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44491 }
44492 arg1 = static_cast< wxWindowVariant >(val1);
44493 }
44494 {
44495 if (!wxPyCheckForApp()) SWIG_fail;
44496 PyThreadState* __tstate = wxPyBeginAllowThreads();
44497 result = wxControl::GetClassDefaultAttributes(arg1);
44498 wxPyEndAllowThreads(__tstate);
44499 if (PyErr_Occurred()) SWIG_fail;
44500 }
44501 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44502 return resultobj;
44503 fail:
44504 return NULL;
44505 }
44506
44507
44508 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44509 PyObject *obj;
44510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44511 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44512 return SWIG_Py_Void();
44513 }
44514
44515 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44516 return SWIG_Python_InitShadowInstance(args);
44517 }
44518
44519 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44520 PyObject *resultobj = 0;
44521 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44522 wxString *arg2 = 0 ;
44523 PyObject *arg3 = (PyObject *) NULL ;
44524 int result;
44525 void *argp1 = 0 ;
44526 int res1 = 0 ;
44527 bool temp2 = false ;
44528 PyObject * obj0 = 0 ;
44529 PyObject * obj1 = 0 ;
44530 PyObject * obj2 = 0 ;
44531 char * kwnames[] = {
44532 (char *) "self",(char *) "item",(char *) "clientData", NULL
44533 };
44534
44535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44537 if (!SWIG_IsOK(res1)) {
44538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44539 }
44540 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44541 {
44542 arg2 = wxString_in_helper(obj1);
44543 if (arg2 == NULL) SWIG_fail;
44544 temp2 = true;
44545 }
44546 if (obj2) {
44547 arg3 = obj2;
44548 }
44549 {
44550 PyThreadState* __tstate = wxPyBeginAllowThreads();
44551 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44552 wxPyEndAllowThreads(__tstate);
44553 if (PyErr_Occurred()) SWIG_fail;
44554 }
44555 resultobj = SWIG_From_int(static_cast< int >(result));
44556 {
44557 if (temp2)
44558 delete arg2;
44559 }
44560 return resultobj;
44561 fail:
44562 {
44563 if (temp2)
44564 delete arg2;
44565 }
44566 return NULL;
44567 }
44568
44569
44570 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44571 PyObject *resultobj = 0;
44572 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44573 wxArrayString *arg2 = 0 ;
44574 void *argp1 = 0 ;
44575 int res1 = 0 ;
44576 bool temp2 = false ;
44577 PyObject * obj0 = 0 ;
44578 PyObject * obj1 = 0 ;
44579 char * kwnames[] = {
44580 (char *) "self",(char *) "strings", NULL
44581 };
44582
44583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44585 if (!SWIG_IsOK(res1)) {
44586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44587 }
44588 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44589 {
44590 if (! PySequence_Check(obj1)) {
44591 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44592 SWIG_fail;
44593 }
44594 arg2 = new wxArrayString;
44595 temp2 = true;
44596 int i, len=PySequence_Length(obj1);
44597 for (i=0; i<len; i++) {
44598 PyObject* item = PySequence_GetItem(obj1, i);
44599 wxString* s = wxString_in_helper(item);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 arg2->Add(*s);
44602 delete s;
44603 Py_DECREF(item);
44604 }
44605 }
44606 {
44607 PyThreadState* __tstate = wxPyBeginAllowThreads();
44608 (arg1)->Append((wxArrayString const &)*arg2);
44609 wxPyEndAllowThreads(__tstate);
44610 if (PyErr_Occurred()) SWIG_fail;
44611 }
44612 resultobj = SWIG_Py_Void();
44613 {
44614 if (temp2) delete arg2;
44615 }
44616 return resultobj;
44617 fail:
44618 {
44619 if (temp2) delete arg2;
44620 }
44621 return NULL;
44622 }
44623
44624
44625 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44626 PyObject *resultobj = 0;
44627 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44628 wxString *arg2 = 0 ;
44629 unsigned int arg3 ;
44630 PyObject *arg4 = (PyObject *) NULL ;
44631 int result;
44632 void *argp1 = 0 ;
44633 int res1 = 0 ;
44634 bool temp2 = false ;
44635 unsigned int val3 ;
44636 int ecode3 = 0 ;
44637 PyObject * obj0 = 0 ;
44638 PyObject * obj1 = 0 ;
44639 PyObject * obj2 = 0 ;
44640 PyObject * obj3 = 0 ;
44641 char * kwnames[] = {
44642 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44643 };
44644
44645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44647 if (!SWIG_IsOK(res1)) {
44648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44649 }
44650 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44651 {
44652 arg2 = wxString_in_helper(obj1);
44653 if (arg2 == NULL) SWIG_fail;
44654 temp2 = true;
44655 }
44656 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44657 if (!SWIG_IsOK(ecode3)) {
44658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44659 }
44660 arg3 = static_cast< unsigned int >(val3);
44661 if (obj3) {
44662 arg4 = obj3;
44663 }
44664 {
44665 PyThreadState* __tstate = wxPyBeginAllowThreads();
44666 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44667 wxPyEndAllowThreads(__tstate);
44668 if (PyErr_Occurred()) SWIG_fail;
44669 }
44670 resultobj = SWIG_From_int(static_cast< int >(result));
44671 {
44672 if (temp2)
44673 delete arg2;
44674 }
44675 return resultobj;
44676 fail:
44677 {
44678 if (temp2)
44679 delete arg2;
44680 }
44681 return NULL;
44682 }
44683
44684
44685 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44686 PyObject *resultobj = 0;
44687 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44688 void *argp1 = 0 ;
44689 int res1 = 0 ;
44690 PyObject *swig_obj[1] ;
44691
44692 if (!args) SWIG_fail;
44693 swig_obj[0] = args;
44694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44695 if (!SWIG_IsOK(res1)) {
44696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44697 }
44698 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44699 {
44700 PyThreadState* __tstate = wxPyBeginAllowThreads();
44701 (arg1)->Clear();
44702 wxPyEndAllowThreads(__tstate);
44703 if (PyErr_Occurred()) SWIG_fail;
44704 }
44705 resultobj = SWIG_Py_Void();
44706 return resultobj;
44707 fail:
44708 return NULL;
44709 }
44710
44711
44712 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44713 PyObject *resultobj = 0;
44714 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44715 unsigned int arg2 ;
44716 void *argp1 = 0 ;
44717 int res1 = 0 ;
44718 unsigned int val2 ;
44719 int ecode2 = 0 ;
44720 PyObject * obj0 = 0 ;
44721 PyObject * obj1 = 0 ;
44722 char * kwnames[] = {
44723 (char *) "self",(char *) "n", NULL
44724 };
44725
44726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44728 if (!SWIG_IsOK(res1)) {
44729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44730 }
44731 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44732 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44733 if (!SWIG_IsOK(ecode2)) {
44734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44735 }
44736 arg2 = static_cast< unsigned int >(val2);
44737 {
44738 PyThreadState* __tstate = wxPyBeginAllowThreads();
44739 (arg1)->Delete(arg2);
44740 wxPyEndAllowThreads(__tstate);
44741 if (PyErr_Occurred()) SWIG_fail;
44742 }
44743 resultobj = SWIG_Py_Void();
44744 return resultobj;
44745 fail:
44746 return NULL;
44747 }
44748
44749
44750 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44751 PyObject *resultobj = 0;
44752 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44753 unsigned int arg2 ;
44754 PyObject *result = 0 ;
44755 void *argp1 = 0 ;
44756 int res1 = 0 ;
44757 unsigned int val2 ;
44758 int ecode2 = 0 ;
44759 PyObject * obj0 = 0 ;
44760 PyObject * obj1 = 0 ;
44761 char * kwnames[] = {
44762 (char *) "self",(char *) "n", NULL
44763 };
44764
44765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44767 if (!SWIG_IsOK(res1)) {
44768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44769 }
44770 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44771 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44772 if (!SWIG_IsOK(ecode2)) {
44773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44774 }
44775 arg2 = static_cast< unsigned int >(val2);
44776 {
44777 PyThreadState* __tstate = wxPyBeginAllowThreads();
44778 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44779 wxPyEndAllowThreads(__tstate);
44780 if (PyErr_Occurred()) SWIG_fail;
44781 }
44782 resultobj = result;
44783 return resultobj;
44784 fail:
44785 return NULL;
44786 }
44787
44788
44789 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44790 PyObject *resultobj = 0;
44791 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44792 unsigned int arg2 ;
44793 PyObject *arg3 = (PyObject *) 0 ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 unsigned int val2 ;
44797 int ecode2 = 0 ;
44798 PyObject * obj0 = 0 ;
44799 PyObject * obj1 = 0 ;
44800 PyObject * obj2 = 0 ;
44801 char * kwnames[] = {
44802 (char *) "self",(char *) "n",(char *) "clientData", NULL
44803 };
44804
44805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44807 if (!SWIG_IsOK(res1)) {
44808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44809 }
44810 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44811 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44812 if (!SWIG_IsOK(ecode2)) {
44813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44814 }
44815 arg2 = static_cast< unsigned int >(val2);
44816 arg3 = obj2;
44817 {
44818 PyThreadState* __tstate = wxPyBeginAllowThreads();
44819 wxItemContainer_SetClientData(arg1,arg2,arg3);
44820 wxPyEndAllowThreads(__tstate);
44821 if (PyErr_Occurred()) SWIG_fail;
44822 }
44823 resultobj = SWIG_Py_Void();
44824 return resultobj;
44825 fail:
44826 return NULL;
44827 }
44828
44829
44830 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44831 PyObject *resultobj = 0;
44832 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44833 unsigned int result;
44834 void *argp1 = 0 ;
44835 int res1 = 0 ;
44836 PyObject *swig_obj[1] ;
44837
44838 if (!args) SWIG_fail;
44839 swig_obj[0] = args;
44840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44841 if (!SWIG_IsOK(res1)) {
44842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44843 }
44844 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44845 {
44846 PyThreadState* __tstate = wxPyBeginAllowThreads();
44847 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44848 wxPyEndAllowThreads(__tstate);
44849 if (PyErr_Occurred()) SWIG_fail;
44850 }
44851 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44852 return resultobj;
44853 fail:
44854 return NULL;
44855 }
44856
44857
44858 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44859 PyObject *resultobj = 0;
44860 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44861 bool result;
44862 void *argp1 = 0 ;
44863 int res1 = 0 ;
44864 PyObject *swig_obj[1] ;
44865
44866 if (!args) SWIG_fail;
44867 swig_obj[0] = args;
44868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44869 if (!SWIG_IsOK(res1)) {
44870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44871 }
44872 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44873 {
44874 PyThreadState* __tstate = wxPyBeginAllowThreads();
44875 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44876 wxPyEndAllowThreads(__tstate);
44877 if (PyErr_Occurred()) SWIG_fail;
44878 }
44879 {
44880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44881 }
44882 return resultobj;
44883 fail:
44884 return NULL;
44885 }
44886
44887
44888 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44889 PyObject *resultobj = 0;
44890 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44891 unsigned int arg2 ;
44892 wxString result;
44893 void *argp1 = 0 ;
44894 int res1 = 0 ;
44895 unsigned int val2 ;
44896 int ecode2 = 0 ;
44897 PyObject * obj0 = 0 ;
44898 PyObject * obj1 = 0 ;
44899 char * kwnames[] = {
44900 (char *) "self",(char *) "n", NULL
44901 };
44902
44903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44905 if (!SWIG_IsOK(res1)) {
44906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44907 }
44908 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44909 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44910 if (!SWIG_IsOK(ecode2)) {
44911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44912 }
44913 arg2 = static_cast< unsigned int >(val2);
44914 {
44915 PyThreadState* __tstate = wxPyBeginAllowThreads();
44916 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44917 wxPyEndAllowThreads(__tstate);
44918 if (PyErr_Occurred()) SWIG_fail;
44919 }
44920 {
44921 #if wxUSE_UNICODE
44922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44923 #else
44924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44925 #endif
44926 }
44927 return resultobj;
44928 fail:
44929 return NULL;
44930 }
44931
44932
44933 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44934 PyObject *resultobj = 0;
44935 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44936 wxArrayString result;
44937 void *argp1 = 0 ;
44938 int res1 = 0 ;
44939 PyObject *swig_obj[1] ;
44940
44941 if (!args) SWIG_fail;
44942 swig_obj[0] = args;
44943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44944 if (!SWIG_IsOK(res1)) {
44945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44946 }
44947 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44948 {
44949 PyThreadState* __tstate = wxPyBeginAllowThreads();
44950 result = ((wxItemContainer const *)arg1)->GetStrings();
44951 wxPyEndAllowThreads(__tstate);
44952 if (PyErr_Occurred()) SWIG_fail;
44953 }
44954 {
44955 resultobj = wxArrayString2PyList_helper(result);
44956 }
44957 return resultobj;
44958 fail:
44959 return NULL;
44960 }
44961
44962
44963 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44964 PyObject *resultobj = 0;
44965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44966 unsigned int arg2 ;
44967 wxString *arg3 = 0 ;
44968 void *argp1 = 0 ;
44969 int res1 = 0 ;
44970 unsigned int val2 ;
44971 int ecode2 = 0 ;
44972 bool temp3 = false ;
44973 PyObject * obj0 = 0 ;
44974 PyObject * obj1 = 0 ;
44975 PyObject * obj2 = 0 ;
44976 char * kwnames[] = {
44977 (char *) "self",(char *) "n",(char *) "s", NULL
44978 };
44979
44980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44982 if (!SWIG_IsOK(res1)) {
44983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44984 }
44985 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44986 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44987 if (!SWIG_IsOK(ecode2)) {
44988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44989 }
44990 arg2 = static_cast< unsigned int >(val2);
44991 {
44992 arg3 = wxString_in_helper(obj2);
44993 if (arg3 == NULL) SWIG_fail;
44994 temp3 = true;
44995 }
44996 {
44997 PyThreadState* __tstate = wxPyBeginAllowThreads();
44998 (arg1)->SetString(arg2,(wxString const &)*arg3);
44999 wxPyEndAllowThreads(__tstate);
45000 if (PyErr_Occurred()) SWIG_fail;
45001 }
45002 resultobj = SWIG_Py_Void();
45003 {
45004 if (temp3)
45005 delete arg3;
45006 }
45007 return resultobj;
45008 fail:
45009 {
45010 if (temp3)
45011 delete arg3;
45012 }
45013 return NULL;
45014 }
45015
45016
45017 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45018 PyObject *resultobj = 0;
45019 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45020 wxString *arg2 = 0 ;
45021 int result;
45022 void *argp1 = 0 ;
45023 int res1 = 0 ;
45024 bool temp2 = false ;
45025 PyObject * obj0 = 0 ;
45026 PyObject * obj1 = 0 ;
45027 char * kwnames[] = {
45028 (char *) "self",(char *) "s", NULL
45029 };
45030
45031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45033 if (!SWIG_IsOK(res1)) {
45034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45035 }
45036 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45037 {
45038 arg2 = wxString_in_helper(obj1);
45039 if (arg2 == NULL) SWIG_fail;
45040 temp2 = true;
45041 }
45042 {
45043 PyThreadState* __tstate = wxPyBeginAllowThreads();
45044 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45045 wxPyEndAllowThreads(__tstate);
45046 if (PyErr_Occurred()) SWIG_fail;
45047 }
45048 resultobj = SWIG_From_int(static_cast< int >(result));
45049 {
45050 if (temp2)
45051 delete arg2;
45052 }
45053 return resultobj;
45054 fail:
45055 {
45056 if (temp2)
45057 delete arg2;
45058 }
45059 return NULL;
45060 }
45061
45062
45063 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45064 PyObject *resultobj = 0;
45065 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45066 int arg2 ;
45067 void *argp1 = 0 ;
45068 int res1 = 0 ;
45069 int val2 ;
45070 int ecode2 = 0 ;
45071 PyObject * obj0 = 0 ;
45072 PyObject * obj1 = 0 ;
45073 char * kwnames[] = {
45074 (char *) "self",(char *) "n", NULL
45075 };
45076
45077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45079 if (!SWIG_IsOK(res1)) {
45080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45081 }
45082 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45083 ecode2 = SWIG_AsVal_int(obj1, &val2);
45084 if (!SWIG_IsOK(ecode2)) {
45085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45086 }
45087 arg2 = static_cast< int >(val2);
45088 {
45089 PyThreadState* __tstate = wxPyBeginAllowThreads();
45090 (arg1)->SetSelection(arg2);
45091 wxPyEndAllowThreads(__tstate);
45092 if (PyErr_Occurred()) SWIG_fail;
45093 }
45094 resultobj = SWIG_Py_Void();
45095 return resultobj;
45096 fail:
45097 return NULL;
45098 }
45099
45100
45101 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45102 PyObject *resultobj = 0;
45103 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45104 int result;
45105 void *argp1 = 0 ;
45106 int res1 = 0 ;
45107 PyObject *swig_obj[1] ;
45108
45109 if (!args) SWIG_fail;
45110 swig_obj[0] = args;
45111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45112 if (!SWIG_IsOK(res1)) {
45113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45114 }
45115 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45116 {
45117 PyThreadState* __tstate = wxPyBeginAllowThreads();
45118 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45119 wxPyEndAllowThreads(__tstate);
45120 if (PyErr_Occurred()) SWIG_fail;
45121 }
45122 resultobj = SWIG_From_int(static_cast< int >(result));
45123 return resultobj;
45124 fail:
45125 return NULL;
45126 }
45127
45128
45129 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45130 PyObject *resultobj = 0;
45131 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45132 wxString *arg2 = 0 ;
45133 bool result;
45134 void *argp1 = 0 ;
45135 int res1 = 0 ;
45136 bool temp2 = false ;
45137 PyObject * obj0 = 0 ;
45138 PyObject * obj1 = 0 ;
45139 char * kwnames[] = {
45140 (char *) "self",(char *) "s", NULL
45141 };
45142
45143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45145 if (!SWIG_IsOK(res1)) {
45146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45147 }
45148 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45149 {
45150 arg2 = wxString_in_helper(obj1);
45151 if (arg2 == NULL) SWIG_fail;
45152 temp2 = true;
45153 }
45154 {
45155 PyThreadState* __tstate = wxPyBeginAllowThreads();
45156 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45157 wxPyEndAllowThreads(__tstate);
45158 if (PyErr_Occurred()) SWIG_fail;
45159 }
45160 {
45161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45162 }
45163 {
45164 if (temp2)
45165 delete arg2;
45166 }
45167 return resultobj;
45168 fail:
45169 {
45170 if (temp2)
45171 delete arg2;
45172 }
45173 return NULL;
45174 }
45175
45176
45177 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45178 PyObject *resultobj = 0;
45179 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45180 wxString result;
45181 void *argp1 = 0 ;
45182 int res1 = 0 ;
45183 PyObject *swig_obj[1] ;
45184
45185 if (!args) SWIG_fail;
45186 swig_obj[0] = args;
45187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45188 if (!SWIG_IsOK(res1)) {
45189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45190 }
45191 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45192 {
45193 PyThreadState* __tstate = wxPyBeginAllowThreads();
45194 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45195 wxPyEndAllowThreads(__tstate);
45196 if (PyErr_Occurred()) SWIG_fail;
45197 }
45198 {
45199 #if wxUSE_UNICODE
45200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45201 #else
45202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45203 #endif
45204 }
45205 return resultobj;
45206 fail:
45207 return NULL;
45208 }
45209
45210
45211 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45212 PyObject *resultobj = 0;
45213 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45214 int arg2 ;
45215 void *argp1 = 0 ;
45216 int res1 = 0 ;
45217 int val2 ;
45218 int ecode2 = 0 ;
45219 PyObject * obj0 = 0 ;
45220 PyObject * obj1 = 0 ;
45221 char * kwnames[] = {
45222 (char *) "self",(char *) "n", NULL
45223 };
45224
45225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45227 if (!SWIG_IsOK(res1)) {
45228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45229 }
45230 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45231 ecode2 = SWIG_AsVal_int(obj1, &val2);
45232 if (!SWIG_IsOK(ecode2)) {
45233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45234 }
45235 arg2 = static_cast< int >(val2);
45236 {
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 (arg1)->Select(arg2);
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 resultobj = SWIG_Py_Void();
45243 return resultobj;
45244 fail:
45245 return NULL;
45246 }
45247
45248
45249 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45250 PyObject *obj;
45251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45252 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45253 return SWIG_Py_Void();
45254 }
45255
45256 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45257 PyObject *obj;
45258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45259 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45260 return SWIG_Py_Void();
45261 }
45262
45263 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45264 PyObject *resultobj = 0;
45265 wxSizerItem *result = 0 ;
45266
45267 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45268 {
45269 PyThreadState* __tstate = wxPyBeginAllowThreads();
45270 result = (wxSizerItem *)new wxSizerItem();
45271 wxPyEndAllowThreads(__tstate);
45272 if (PyErr_Occurred()) SWIG_fail;
45273 }
45274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45275 return resultobj;
45276 fail:
45277 return NULL;
45278 }
45279
45280
45281 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45282 PyObject *resultobj = 0;
45283 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45284 void *argp1 = 0 ;
45285 int res1 = 0 ;
45286 PyObject *swig_obj[1] ;
45287
45288 if (!args) SWIG_fail;
45289 swig_obj[0] = args;
45290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45291 if (!SWIG_IsOK(res1)) {
45292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45293 }
45294 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45295 {
45296 PyThreadState* __tstate = wxPyBeginAllowThreads();
45297 delete arg1;
45298
45299 wxPyEndAllowThreads(__tstate);
45300 if (PyErr_Occurred()) SWIG_fail;
45301 }
45302 resultobj = SWIG_Py_Void();
45303 return resultobj;
45304 fail:
45305 return NULL;
45306 }
45307
45308
45309 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45310 PyObject *resultobj = 0;
45311 wxWindow *arg1 = (wxWindow *) 0 ;
45312 int arg2 ;
45313 int arg3 ;
45314 int arg4 ;
45315 PyObject *arg5 = (PyObject *) NULL ;
45316 wxSizerItem *result = 0 ;
45317 void *argp1 = 0 ;
45318 int res1 = 0 ;
45319 int val2 ;
45320 int ecode2 = 0 ;
45321 int val3 ;
45322 int ecode3 = 0 ;
45323 int val4 ;
45324 int ecode4 = 0 ;
45325 PyObject * obj0 = 0 ;
45326 PyObject * obj1 = 0 ;
45327 PyObject * obj2 = 0 ;
45328 PyObject * obj3 = 0 ;
45329 PyObject * obj4 = 0 ;
45330 char * kwnames[] = {
45331 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45332 };
45333
45334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45336 if (!SWIG_IsOK(res1)) {
45337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45338 }
45339 arg1 = reinterpret_cast< wxWindow * >(argp1);
45340 ecode2 = SWIG_AsVal_int(obj1, &val2);
45341 if (!SWIG_IsOK(ecode2)) {
45342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45343 }
45344 arg2 = static_cast< int >(val2);
45345 ecode3 = SWIG_AsVal_int(obj2, &val3);
45346 if (!SWIG_IsOK(ecode3)) {
45347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45348 }
45349 arg3 = static_cast< int >(val3);
45350 ecode4 = SWIG_AsVal_int(obj3, &val4);
45351 if (!SWIG_IsOK(ecode4)) {
45352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45353 }
45354 arg4 = static_cast< int >(val4);
45355 if (obj4) {
45356 arg5 = obj4;
45357 }
45358 {
45359 PyThreadState* __tstate = wxPyBeginAllowThreads();
45360 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45361 wxPyEndAllowThreads(__tstate);
45362 if (PyErr_Occurred()) SWIG_fail;
45363 }
45364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45365 return resultobj;
45366 fail:
45367 return NULL;
45368 }
45369
45370
45371 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45372 PyObject *resultobj = 0;
45373 int arg1 ;
45374 int arg2 ;
45375 int arg3 ;
45376 int arg4 ;
45377 int arg5 ;
45378 PyObject *arg6 = (PyObject *) NULL ;
45379 wxSizerItem *result = 0 ;
45380 int val1 ;
45381 int ecode1 = 0 ;
45382 int val2 ;
45383 int ecode2 = 0 ;
45384 int val3 ;
45385 int ecode3 = 0 ;
45386 int val4 ;
45387 int ecode4 = 0 ;
45388 int val5 ;
45389 int ecode5 = 0 ;
45390 PyObject * obj0 = 0 ;
45391 PyObject * obj1 = 0 ;
45392 PyObject * obj2 = 0 ;
45393 PyObject * obj3 = 0 ;
45394 PyObject * obj4 = 0 ;
45395 PyObject * obj5 = 0 ;
45396 char * kwnames[] = {
45397 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45398 };
45399
45400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45401 ecode1 = SWIG_AsVal_int(obj0, &val1);
45402 if (!SWIG_IsOK(ecode1)) {
45403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45404 }
45405 arg1 = static_cast< int >(val1);
45406 ecode2 = SWIG_AsVal_int(obj1, &val2);
45407 if (!SWIG_IsOK(ecode2)) {
45408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45409 }
45410 arg2 = static_cast< int >(val2);
45411 ecode3 = SWIG_AsVal_int(obj2, &val3);
45412 if (!SWIG_IsOK(ecode3)) {
45413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45414 }
45415 arg3 = static_cast< int >(val3);
45416 ecode4 = SWIG_AsVal_int(obj3, &val4);
45417 if (!SWIG_IsOK(ecode4)) {
45418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45419 }
45420 arg4 = static_cast< int >(val4);
45421 ecode5 = SWIG_AsVal_int(obj4, &val5);
45422 if (!SWIG_IsOK(ecode5)) {
45423 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45424 }
45425 arg5 = static_cast< int >(val5);
45426 if (obj5) {
45427 arg6 = obj5;
45428 }
45429 {
45430 PyThreadState* __tstate = wxPyBeginAllowThreads();
45431 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45432 wxPyEndAllowThreads(__tstate);
45433 if (PyErr_Occurred()) SWIG_fail;
45434 }
45435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45436 return resultobj;
45437 fail:
45438 return NULL;
45439 }
45440
45441
45442 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45443 PyObject *resultobj = 0;
45444 wxSizer *arg1 = (wxSizer *) 0 ;
45445 int arg2 ;
45446 int arg3 ;
45447 int arg4 ;
45448 PyObject *arg5 = (PyObject *) NULL ;
45449 wxSizerItem *result = 0 ;
45450 int res1 = 0 ;
45451 int val2 ;
45452 int ecode2 = 0 ;
45453 int val3 ;
45454 int ecode3 = 0 ;
45455 int val4 ;
45456 int ecode4 = 0 ;
45457 PyObject * obj0 = 0 ;
45458 PyObject * obj1 = 0 ;
45459 PyObject * obj2 = 0 ;
45460 PyObject * obj3 = 0 ;
45461 PyObject * obj4 = 0 ;
45462 char * kwnames[] = {
45463 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45464 };
45465
45466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45467 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45468 if (!SWIG_IsOK(res1)) {
45469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45470 }
45471 ecode2 = SWIG_AsVal_int(obj1, &val2);
45472 if (!SWIG_IsOK(ecode2)) {
45473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45474 }
45475 arg2 = static_cast< int >(val2);
45476 ecode3 = SWIG_AsVal_int(obj2, &val3);
45477 if (!SWIG_IsOK(ecode3)) {
45478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45479 }
45480 arg3 = static_cast< int >(val3);
45481 ecode4 = SWIG_AsVal_int(obj3, &val4);
45482 if (!SWIG_IsOK(ecode4)) {
45483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45484 }
45485 arg4 = static_cast< int >(val4);
45486 if (obj4) {
45487 arg5 = obj4;
45488 }
45489 {
45490 PyThreadState* __tstate = wxPyBeginAllowThreads();
45491 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45503 PyObject *resultobj = 0;
45504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45505 void *argp1 = 0 ;
45506 int res1 = 0 ;
45507 PyObject *swig_obj[1] ;
45508
45509 if (!args) SWIG_fail;
45510 swig_obj[0] = args;
45511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45512 if (!SWIG_IsOK(res1)) {
45513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45514 }
45515 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45516 {
45517 PyThreadState* __tstate = wxPyBeginAllowThreads();
45518 (arg1)->DeleteWindows();
45519 wxPyEndAllowThreads(__tstate);
45520 if (PyErr_Occurred()) SWIG_fail;
45521 }
45522 resultobj = SWIG_Py_Void();
45523 return resultobj;
45524 fail:
45525 return NULL;
45526 }
45527
45528
45529 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45530 PyObject *resultobj = 0;
45531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45532 void *argp1 = 0 ;
45533 int res1 = 0 ;
45534 PyObject *swig_obj[1] ;
45535
45536 if (!args) SWIG_fail;
45537 swig_obj[0] = args;
45538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45539 if (!SWIG_IsOK(res1)) {
45540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45541 }
45542 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45543 {
45544 PyThreadState* __tstate = wxPyBeginAllowThreads();
45545 (arg1)->DetachSizer();
45546 wxPyEndAllowThreads(__tstate);
45547 if (PyErr_Occurred()) SWIG_fail;
45548 }
45549 resultobj = SWIG_Py_Void();
45550 return resultobj;
45551 fail:
45552 return NULL;
45553 }
45554
45555
45556 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45557 PyObject *resultobj = 0;
45558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45559 wxSize result;
45560 void *argp1 = 0 ;
45561 int res1 = 0 ;
45562 PyObject *swig_obj[1] ;
45563
45564 if (!args) SWIG_fail;
45565 swig_obj[0] = args;
45566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45567 if (!SWIG_IsOK(res1)) {
45568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45569 }
45570 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45571 {
45572 PyThreadState* __tstate = wxPyBeginAllowThreads();
45573 result = (arg1)->GetSize();
45574 wxPyEndAllowThreads(__tstate);
45575 if (PyErr_Occurred()) SWIG_fail;
45576 }
45577 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45578 return resultobj;
45579 fail:
45580 return NULL;
45581 }
45582
45583
45584 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45585 PyObject *resultobj = 0;
45586 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45587 wxSize result;
45588 void *argp1 = 0 ;
45589 int res1 = 0 ;
45590 PyObject *swig_obj[1] ;
45591
45592 if (!args) SWIG_fail;
45593 swig_obj[0] = args;
45594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45595 if (!SWIG_IsOK(res1)) {
45596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45597 }
45598 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45599 {
45600 PyThreadState* __tstate = wxPyBeginAllowThreads();
45601 result = (arg1)->CalcMin();
45602 wxPyEndAllowThreads(__tstate);
45603 if (PyErr_Occurred()) SWIG_fail;
45604 }
45605 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45606 return resultobj;
45607 fail:
45608 return NULL;
45609 }
45610
45611
45612 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45613 PyObject *resultobj = 0;
45614 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45615 wxPoint *arg2 = 0 ;
45616 wxSize *arg3 = 0 ;
45617 void *argp1 = 0 ;
45618 int res1 = 0 ;
45619 wxPoint temp2 ;
45620 wxSize temp3 ;
45621 PyObject * obj0 = 0 ;
45622 PyObject * obj1 = 0 ;
45623 PyObject * obj2 = 0 ;
45624 char * kwnames[] = {
45625 (char *) "self",(char *) "pos",(char *) "size", NULL
45626 };
45627
45628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45630 if (!SWIG_IsOK(res1)) {
45631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45632 }
45633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45634 {
45635 arg2 = &temp2;
45636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45637 }
45638 {
45639 arg3 = &temp3;
45640 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45641 }
45642 {
45643 PyThreadState* __tstate = wxPyBeginAllowThreads();
45644 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45645 wxPyEndAllowThreads(__tstate);
45646 if (PyErr_Occurred()) SWIG_fail;
45647 }
45648 resultobj = SWIG_Py_Void();
45649 return resultobj;
45650 fail:
45651 return NULL;
45652 }
45653
45654
45655 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45656 PyObject *resultobj = 0;
45657 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45658 wxSize result;
45659 void *argp1 = 0 ;
45660 int res1 = 0 ;
45661 PyObject *swig_obj[1] ;
45662
45663 if (!args) SWIG_fail;
45664 swig_obj[0] = args;
45665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45666 if (!SWIG_IsOK(res1)) {
45667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45668 }
45669 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45670 {
45671 PyThreadState* __tstate = wxPyBeginAllowThreads();
45672 result = (arg1)->GetMinSize();
45673 wxPyEndAllowThreads(__tstate);
45674 if (PyErr_Occurred()) SWIG_fail;
45675 }
45676 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45677 return resultobj;
45678 fail:
45679 return NULL;
45680 }
45681
45682
45683 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45684 PyObject *resultobj = 0;
45685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45686 wxSize result;
45687 void *argp1 = 0 ;
45688 int res1 = 0 ;
45689 PyObject *swig_obj[1] ;
45690
45691 if (!args) SWIG_fail;
45692 swig_obj[0] = args;
45693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45694 if (!SWIG_IsOK(res1)) {
45695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45696 }
45697 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45698 {
45699 PyThreadState* __tstate = wxPyBeginAllowThreads();
45700 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45701 wxPyEndAllowThreads(__tstate);
45702 if (PyErr_Occurred()) SWIG_fail;
45703 }
45704 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45705 return resultobj;
45706 fail:
45707 return NULL;
45708 }
45709
45710
45711 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45712 PyObject *resultobj = 0;
45713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45714 int arg2 ;
45715 int arg3 ;
45716 void *argp1 = 0 ;
45717 int res1 = 0 ;
45718 int val2 ;
45719 int ecode2 = 0 ;
45720 int val3 ;
45721 int ecode3 = 0 ;
45722 PyObject * obj0 = 0 ;
45723 PyObject * obj1 = 0 ;
45724 PyObject * obj2 = 0 ;
45725 char * kwnames[] = {
45726 (char *) "self",(char *) "x",(char *) "y", NULL
45727 };
45728
45729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45731 if (!SWIG_IsOK(res1)) {
45732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45733 }
45734 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45735 ecode2 = SWIG_AsVal_int(obj1, &val2);
45736 if (!SWIG_IsOK(ecode2)) {
45737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45738 }
45739 arg2 = static_cast< int >(val2);
45740 ecode3 = SWIG_AsVal_int(obj2, &val3);
45741 if (!SWIG_IsOK(ecode3)) {
45742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45743 }
45744 arg3 = static_cast< int >(val3);
45745 {
45746 PyThreadState* __tstate = wxPyBeginAllowThreads();
45747 (arg1)->SetInitSize(arg2,arg3);
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 resultobj = SWIG_Py_Void();
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45759 PyObject *resultobj = 0;
45760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45761 int arg2 ;
45762 int arg3 ;
45763 void *argp1 = 0 ;
45764 int res1 = 0 ;
45765 int val2 ;
45766 int ecode2 = 0 ;
45767 int val3 ;
45768 int ecode3 = 0 ;
45769 PyObject * obj0 = 0 ;
45770 PyObject * obj1 = 0 ;
45771 PyObject * obj2 = 0 ;
45772 char * kwnames[] = {
45773 (char *) "self",(char *) "width",(char *) "height", NULL
45774 };
45775
45776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45778 if (!SWIG_IsOK(res1)) {
45779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45780 }
45781 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45782 ecode2 = SWIG_AsVal_int(obj1, &val2);
45783 if (!SWIG_IsOK(ecode2)) {
45784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45785 }
45786 arg2 = static_cast< int >(val2);
45787 ecode3 = SWIG_AsVal_int(obj2, &val3);
45788 if (!SWIG_IsOK(ecode3)) {
45789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45790 }
45791 arg3 = static_cast< int >(val3);
45792 {
45793 PyThreadState* __tstate = wxPyBeginAllowThreads();
45794 (arg1)->SetRatio(arg2,arg3);
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 resultobj = SWIG_Py_Void();
45799 return resultobj;
45800 fail:
45801 return NULL;
45802 }
45803
45804
45805 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45806 PyObject *resultobj = 0;
45807 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45808 wxSize *arg2 = 0 ;
45809 void *argp1 = 0 ;
45810 int res1 = 0 ;
45811 wxSize temp2 ;
45812 PyObject * obj0 = 0 ;
45813 PyObject * obj1 = 0 ;
45814 char * kwnames[] = {
45815 (char *) "self",(char *) "size", NULL
45816 };
45817
45818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45820 if (!SWIG_IsOK(res1)) {
45821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45822 }
45823 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45824 {
45825 arg2 = &temp2;
45826 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45827 }
45828 {
45829 PyThreadState* __tstate = wxPyBeginAllowThreads();
45830 (arg1)->SetRatio((wxSize const &)*arg2);
45831 wxPyEndAllowThreads(__tstate);
45832 if (PyErr_Occurred()) SWIG_fail;
45833 }
45834 resultobj = SWIG_Py_Void();
45835 return resultobj;
45836 fail:
45837 return NULL;
45838 }
45839
45840
45841 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45842 PyObject *resultobj = 0;
45843 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45844 float arg2 ;
45845 void *argp1 = 0 ;
45846 int res1 = 0 ;
45847 float val2 ;
45848 int ecode2 = 0 ;
45849 PyObject * obj0 = 0 ;
45850 PyObject * obj1 = 0 ;
45851 char * kwnames[] = {
45852 (char *) "self",(char *) "ratio", NULL
45853 };
45854
45855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45857 if (!SWIG_IsOK(res1)) {
45858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45859 }
45860 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45861 ecode2 = SWIG_AsVal_float(obj1, &val2);
45862 if (!SWIG_IsOK(ecode2)) {
45863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45864 }
45865 arg2 = static_cast< float >(val2);
45866 {
45867 PyThreadState* __tstate = wxPyBeginAllowThreads();
45868 (arg1)->SetRatio(arg2);
45869 wxPyEndAllowThreads(__tstate);
45870 if (PyErr_Occurred()) SWIG_fail;
45871 }
45872 resultobj = SWIG_Py_Void();
45873 return resultobj;
45874 fail:
45875 return NULL;
45876 }
45877
45878
45879 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45880 PyObject *resultobj = 0;
45881 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45882 float result;
45883 void *argp1 = 0 ;
45884 int res1 = 0 ;
45885 PyObject *swig_obj[1] ;
45886
45887 if (!args) SWIG_fail;
45888 swig_obj[0] = args;
45889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45890 if (!SWIG_IsOK(res1)) {
45891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45892 }
45893 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45894 {
45895 PyThreadState* __tstate = wxPyBeginAllowThreads();
45896 result = (float)(arg1)->GetRatio();
45897 wxPyEndAllowThreads(__tstate);
45898 if (PyErr_Occurred()) SWIG_fail;
45899 }
45900 resultobj = SWIG_From_float(static_cast< float >(result));
45901 return resultobj;
45902 fail:
45903 return NULL;
45904 }
45905
45906
45907 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45908 PyObject *resultobj = 0;
45909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45910 wxRect result;
45911 void *argp1 = 0 ;
45912 int res1 = 0 ;
45913 PyObject *swig_obj[1] ;
45914
45915 if (!args) SWIG_fail;
45916 swig_obj[0] = args;
45917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45918 if (!SWIG_IsOK(res1)) {
45919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45920 }
45921 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45922 {
45923 PyThreadState* __tstate = wxPyBeginAllowThreads();
45924 result = (arg1)->GetRect();
45925 wxPyEndAllowThreads(__tstate);
45926 if (PyErr_Occurred()) SWIG_fail;
45927 }
45928 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45929 return resultobj;
45930 fail:
45931 return NULL;
45932 }
45933
45934
45935 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45936 PyObject *resultobj = 0;
45937 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45938 bool result;
45939 void *argp1 = 0 ;
45940 int res1 = 0 ;
45941 PyObject *swig_obj[1] ;
45942
45943 if (!args) SWIG_fail;
45944 swig_obj[0] = args;
45945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45946 if (!SWIG_IsOK(res1)) {
45947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45948 }
45949 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45950 {
45951 PyThreadState* __tstate = wxPyBeginAllowThreads();
45952 result = (bool)(arg1)->IsWindow();
45953 wxPyEndAllowThreads(__tstate);
45954 if (PyErr_Occurred()) SWIG_fail;
45955 }
45956 {
45957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45958 }
45959 return resultobj;
45960 fail:
45961 return NULL;
45962 }
45963
45964
45965 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45966 PyObject *resultobj = 0;
45967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45968 bool result;
45969 void *argp1 = 0 ;
45970 int res1 = 0 ;
45971 PyObject *swig_obj[1] ;
45972
45973 if (!args) SWIG_fail;
45974 swig_obj[0] = args;
45975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45976 if (!SWIG_IsOK(res1)) {
45977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45978 }
45979 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45980 {
45981 PyThreadState* __tstate = wxPyBeginAllowThreads();
45982 result = (bool)(arg1)->IsSizer();
45983 wxPyEndAllowThreads(__tstate);
45984 if (PyErr_Occurred()) SWIG_fail;
45985 }
45986 {
45987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45988 }
45989 return resultobj;
45990 fail:
45991 return NULL;
45992 }
45993
45994
45995 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45996 PyObject *resultobj = 0;
45997 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45998 bool result;
45999 void *argp1 = 0 ;
46000 int res1 = 0 ;
46001 PyObject *swig_obj[1] ;
46002
46003 if (!args) SWIG_fail;
46004 swig_obj[0] = args;
46005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46006 if (!SWIG_IsOK(res1)) {
46007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46008 }
46009 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46010 {
46011 PyThreadState* __tstate = wxPyBeginAllowThreads();
46012 result = (bool)(arg1)->IsSpacer();
46013 wxPyEndAllowThreads(__tstate);
46014 if (PyErr_Occurred()) SWIG_fail;
46015 }
46016 {
46017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46018 }
46019 return resultobj;
46020 fail:
46021 return NULL;
46022 }
46023
46024
46025 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46026 PyObject *resultobj = 0;
46027 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46028 int arg2 ;
46029 void *argp1 = 0 ;
46030 int res1 = 0 ;
46031 int val2 ;
46032 int ecode2 = 0 ;
46033 PyObject * obj0 = 0 ;
46034 PyObject * obj1 = 0 ;
46035 char * kwnames[] = {
46036 (char *) "self",(char *) "proportion", NULL
46037 };
46038
46039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46041 if (!SWIG_IsOK(res1)) {
46042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46043 }
46044 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46045 ecode2 = SWIG_AsVal_int(obj1, &val2);
46046 if (!SWIG_IsOK(ecode2)) {
46047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46048 }
46049 arg2 = static_cast< int >(val2);
46050 {
46051 PyThreadState* __tstate = wxPyBeginAllowThreads();
46052 (arg1)->SetProportion(arg2);
46053 wxPyEndAllowThreads(__tstate);
46054 if (PyErr_Occurred()) SWIG_fail;
46055 }
46056 resultobj = SWIG_Py_Void();
46057 return resultobj;
46058 fail:
46059 return NULL;
46060 }
46061
46062
46063 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46064 PyObject *resultobj = 0;
46065 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46066 int result;
46067 void *argp1 = 0 ;
46068 int res1 = 0 ;
46069 PyObject *swig_obj[1] ;
46070
46071 if (!args) SWIG_fail;
46072 swig_obj[0] = args;
46073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46074 if (!SWIG_IsOK(res1)) {
46075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46076 }
46077 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46078 {
46079 PyThreadState* __tstate = wxPyBeginAllowThreads();
46080 result = (int)(arg1)->GetProportion();
46081 wxPyEndAllowThreads(__tstate);
46082 if (PyErr_Occurred()) SWIG_fail;
46083 }
46084 resultobj = SWIG_From_int(static_cast< int >(result));
46085 return resultobj;
46086 fail:
46087 return NULL;
46088 }
46089
46090
46091 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46092 PyObject *resultobj = 0;
46093 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46094 int arg2 ;
46095 void *argp1 = 0 ;
46096 int res1 = 0 ;
46097 int val2 ;
46098 int ecode2 = 0 ;
46099 PyObject * obj0 = 0 ;
46100 PyObject * obj1 = 0 ;
46101 char * kwnames[] = {
46102 (char *) "self",(char *) "flag", NULL
46103 };
46104
46105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46107 if (!SWIG_IsOK(res1)) {
46108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46109 }
46110 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46111 ecode2 = SWIG_AsVal_int(obj1, &val2);
46112 if (!SWIG_IsOK(ecode2)) {
46113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46114 }
46115 arg2 = static_cast< int >(val2);
46116 {
46117 PyThreadState* __tstate = wxPyBeginAllowThreads();
46118 (arg1)->SetFlag(arg2);
46119 wxPyEndAllowThreads(__tstate);
46120 if (PyErr_Occurred()) SWIG_fail;
46121 }
46122 resultobj = SWIG_Py_Void();
46123 return resultobj;
46124 fail:
46125 return NULL;
46126 }
46127
46128
46129 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46130 PyObject *resultobj = 0;
46131 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46132 int result;
46133 void *argp1 = 0 ;
46134 int res1 = 0 ;
46135 PyObject *swig_obj[1] ;
46136
46137 if (!args) SWIG_fail;
46138 swig_obj[0] = args;
46139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46140 if (!SWIG_IsOK(res1)) {
46141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46142 }
46143 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46144 {
46145 PyThreadState* __tstate = wxPyBeginAllowThreads();
46146 result = (int)(arg1)->GetFlag();
46147 wxPyEndAllowThreads(__tstate);
46148 if (PyErr_Occurred()) SWIG_fail;
46149 }
46150 resultobj = SWIG_From_int(static_cast< int >(result));
46151 return resultobj;
46152 fail:
46153 return NULL;
46154 }
46155
46156
46157 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46158 PyObject *resultobj = 0;
46159 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46160 int arg2 ;
46161 void *argp1 = 0 ;
46162 int res1 = 0 ;
46163 int val2 ;
46164 int ecode2 = 0 ;
46165 PyObject * obj0 = 0 ;
46166 PyObject * obj1 = 0 ;
46167 char * kwnames[] = {
46168 (char *) "self",(char *) "border", NULL
46169 };
46170
46171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46173 if (!SWIG_IsOK(res1)) {
46174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46175 }
46176 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46177 ecode2 = SWIG_AsVal_int(obj1, &val2);
46178 if (!SWIG_IsOK(ecode2)) {
46179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46180 }
46181 arg2 = static_cast< int >(val2);
46182 {
46183 PyThreadState* __tstate = wxPyBeginAllowThreads();
46184 (arg1)->SetBorder(arg2);
46185 wxPyEndAllowThreads(__tstate);
46186 if (PyErr_Occurred()) SWIG_fail;
46187 }
46188 resultobj = SWIG_Py_Void();
46189 return resultobj;
46190 fail:
46191 return NULL;
46192 }
46193
46194
46195 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46196 PyObject *resultobj = 0;
46197 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46198 int result;
46199 void *argp1 = 0 ;
46200 int res1 = 0 ;
46201 PyObject *swig_obj[1] ;
46202
46203 if (!args) SWIG_fail;
46204 swig_obj[0] = args;
46205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46206 if (!SWIG_IsOK(res1)) {
46207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46208 }
46209 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46210 {
46211 PyThreadState* __tstate = wxPyBeginAllowThreads();
46212 result = (int)(arg1)->GetBorder();
46213 wxPyEndAllowThreads(__tstate);
46214 if (PyErr_Occurred()) SWIG_fail;
46215 }
46216 resultobj = SWIG_From_int(static_cast< int >(result));
46217 return resultobj;
46218 fail:
46219 return NULL;
46220 }
46221
46222
46223 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46224 PyObject *resultobj = 0;
46225 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46226 wxWindow *result = 0 ;
46227 void *argp1 = 0 ;
46228 int res1 = 0 ;
46229 PyObject *swig_obj[1] ;
46230
46231 if (!args) SWIG_fail;
46232 swig_obj[0] = args;
46233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46234 if (!SWIG_IsOK(res1)) {
46235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46236 }
46237 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46238 {
46239 PyThreadState* __tstate = wxPyBeginAllowThreads();
46240 result = (wxWindow *)(arg1)->GetWindow();
46241 wxPyEndAllowThreads(__tstate);
46242 if (PyErr_Occurred()) SWIG_fail;
46243 }
46244 {
46245 resultobj = wxPyMake_wxObject(result, 0);
46246 }
46247 return resultobj;
46248 fail:
46249 return NULL;
46250 }
46251
46252
46253 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46254 PyObject *resultobj = 0;
46255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46256 wxWindow *arg2 = (wxWindow *) 0 ;
46257 void *argp1 = 0 ;
46258 int res1 = 0 ;
46259 void *argp2 = 0 ;
46260 int res2 = 0 ;
46261 PyObject * obj0 = 0 ;
46262 PyObject * obj1 = 0 ;
46263 char * kwnames[] = {
46264 (char *) "self",(char *) "window", NULL
46265 };
46266
46267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46269 if (!SWIG_IsOK(res1)) {
46270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46271 }
46272 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46274 if (!SWIG_IsOK(res2)) {
46275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46276 }
46277 arg2 = reinterpret_cast< wxWindow * >(argp2);
46278 {
46279 PyThreadState* __tstate = wxPyBeginAllowThreads();
46280 (arg1)->SetWindow(arg2);
46281 wxPyEndAllowThreads(__tstate);
46282 if (PyErr_Occurred()) SWIG_fail;
46283 }
46284 resultobj = SWIG_Py_Void();
46285 return resultobj;
46286 fail:
46287 return NULL;
46288 }
46289
46290
46291 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46292 PyObject *resultobj = 0;
46293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46294 wxSizer *result = 0 ;
46295 void *argp1 = 0 ;
46296 int res1 = 0 ;
46297 PyObject *swig_obj[1] ;
46298
46299 if (!args) SWIG_fail;
46300 swig_obj[0] = args;
46301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46302 if (!SWIG_IsOK(res1)) {
46303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46304 }
46305 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46306 {
46307 PyThreadState* __tstate = wxPyBeginAllowThreads();
46308 result = (wxSizer *)(arg1)->GetSizer();
46309 wxPyEndAllowThreads(__tstate);
46310 if (PyErr_Occurred()) SWIG_fail;
46311 }
46312 {
46313 resultobj = wxPyMake_wxObject(result, (bool)0);
46314 }
46315 return resultobj;
46316 fail:
46317 return NULL;
46318 }
46319
46320
46321 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46322 PyObject *resultobj = 0;
46323 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46324 wxSizer *arg2 = (wxSizer *) 0 ;
46325 void *argp1 = 0 ;
46326 int res1 = 0 ;
46327 int res2 = 0 ;
46328 PyObject * obj0 = 0 ;
46329 PyObject * obj1 = 0 ;
46330 char * kwnames[] = {
46331 (char *) "self",(char *) "sizer", NULL
46332 };
46333
46334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46336 if (!SWIG_IsOK(res1)) {
46337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46338 }
46339 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46340 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46341 if (!SWIG_IsOK(res2)) {
46342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46343 }
46344 {
46345 PyThreadState* __tstate = wxPyBeginAllowThreads();
46346 (arg1)->SetSizer(arg2);
46347 wxPyEndAllowThreads(__tstate);
46348 if (PyErr_Occurred()) SWIG_fail;
46349 }
46350 resultobj = SWIG_Py_Void();
46351 return resultobj;
46352 fail:
46353 return NULL;
46354 }
46355
46356
46357 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46358 PyObject *resultobj = 0;
46359 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46360 wxSize *result = 0 ;
46361 void *argp1 = 0 ;
46362 int res1 = 0 ;
46363 PyObject *swig_obj[1] ;
46364
46365 if (!args) SWIG_fail;
46366 swig_obj[0] = args;
46367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46368 if (!SWIG_IsOK(res1)) {
46369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46370 }
46371 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46372 {
46373 PyThreadState* __tstate = wxPyBeginAllowThreads();
46374 {
46375 wxSize const &_result_ref = (arg1)->GetSpacer();
46376 result = (wxSize *) &_result_ref;
46377 }
46378 wxPyEndAllowThreads(__tstate);
46379 if (PyErr_Occurred()) SWIG_fail;
46380 }
46381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46382 return resultobj;
46383 fail:
46384 return NULL;
46385 }
46386
46387
46388 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46389 PyObject *resultobj = 0;
46390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46391 wxSize *arg2 = 0 ;
46392 void *argp1 = 0 ;
46393 int res1 = 0 ;
46394 wxSize temp2 ;
46395 PyObject * obj0 = 0 ;
46396 PyObject * obj1 = 0 ;
46397 char * kwnames[] = {
46398 (char *) "self",(char *) "size", NULL
46399 };
46400
46401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46403 if (!SWIG_IsOK(res1)) {
46404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46405 }
46406 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46407 {
46408 arg2 = &temp2;
46409 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46410 }
46411 {
46412 PyThreadState* __tstate = wxPyBeginAllowThreads();
46413 (arg1)->SetSpacer((wxSize const &)*arg2);
46414 wxPyEndAllowThreads(__tstate);
46415 if (PyErr_Occurred()) SWIG_fail;
46416 }
46417 resultobj = SWIG_Py_Void();
46418 return resultobj;
46419 fail:
46420 return NULL;
46421 }
46422
46423
46424 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46425 PyObject *resultobj = 0;
46426 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46427 bool arg2 ;
46428 void *argp1 = 0 ;
46429 int res1 = 0 ;
46430 bool val2 ;
46431 int ecode2 = 0 ;
46432 PyObject * obj0 = 0 ;
46433 PyObject * obj1 = 0 ;
46434 char * kwnames[] = {
46435 (char *) "self",(char *) "show", NULL
46436 };
46437
46438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46440 if (!SWIG_IsOK(res1)) {
46441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46442 }
46443 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46444 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46445 if (!SWIG_IsOK(ecode2)) {
46446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46447 }
46448 arg2 = static_cast< bool >(val2);
46449 {
46450 PyThreadState* __tstate = wxPyBeginAllowThreads();
46451 (arg1)->Show(arg2);
46452 wxPyEndAllowThreads(__tstate);
46453 if (PyErr_Occurred()) SWIG_fail;
46454 }
46455 resultobj = SWIG_Py_Void();
46456 return resultobj;
46457 fail:
46458 return NULL;
46459 }
46460
46461
46462 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46463 PyObject *resultobj = 0;
46464 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46465 bool result;
46466 void *argp1 = 0 ;
46467 int res1 = 0 ;
46468 PyObject *swig_obj[1] ;
46469
46470 if (!args) SWIG_fail;
46471 swig_obj[0] = args;
46472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46473 if (!SWIG_IsOK(res1)) {
46474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46475 }
46476 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46477 {
46478 PyThreadState* __tstate = wxPyBeginAllowThreads();
46479 result = (bool)(arg1)->IsShown();
46480 wxPyEndAllowThreads(__tstate);
46481 if (PyErr_Occurred()) SWIG_fail;
46482 }
46483 {
46484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46485 }
46486 return resultobj;
46487 fail:
46488 return NULL;
46489 }
46490
46491
46492 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46493 PyObject *resultobj = 0;
46494 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46495 wxPoint result;
46496 void *argp1 = 0 ;
46497 int res1 = 0 ;
46498 PyObject *swig_obj[1] ;
46499
46500 if (!args) SWIG_fail;
46501 swig_obj[0] = args;
46502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46503 if (!SWIG_IsOK(res1)) {
46504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46505 }
46506 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46507 {
46508 PyThreadState* __tstate = wxPyBeginAllowThreads();
46509 result = (arg1)->GetPosition();
46510 wxPyEndAllowThreads(__tstate);
46511 if (PyErr_Occurred()) SWIG_fail;
46512 }
46513 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46514 return resultobj;
46515 fail:
46516 return NULL;
46517 }
46518
46519
46520 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46521 PyObject *resultobj = 0;
46522 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46523 PyObject *result = 0 ;
46524 void *argp1 = 0 ;
46525 int res1 = 0 ;
46526 PyObject *swig_obj[1] ;
46527
46528 if (!args) SWIG_fail;
46529 swig_obj[0] = args;
46530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46531 if (!SWIG_IsOK(res1)) {
46532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46533 }
46534 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46535 {
46536 PyThreadState* __tstate = wxPyBeginAllowThreads();
46537 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46538 wxPyEndAllowThreads(__tstate);
46539 if (PyErr_Occurred()) SWIG_fail;
46540 }
46541 resultobj = result;
46542 return resultobj;
46543 fail:
46544 return NULL;
46545 }
46546
46547
46548 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46549 PyObject *resultobj = 0;
46550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46551 PyObject *arg2 = (PyObject *) 0 ;
46552 void *argp1 = 0 ;
46553 int res1 = 0 ;
46554 PyObject * obj0 = 0 ;
46555 PyObject * obj1 = 0 ;
46556 char * kwnames[] = {
46557 (char *) "self",(char *) "userData", NULL
46558 };
46559
46560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46562 if (!SWIG_IsOK(res1)) {
46563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46564 }
46565 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46566 arg2 = obj1;
46567 {
46568 PyThreadState* __tstate = wxPyBeginAllowThreads();
46569 wxSizerItem_SetUserData(arg1,arg2);
46570 wxPyEndAllowThreads(__tstate);
46571 if (PyErr_Occurred()) SWIG_fail;
46572 }
46573 resultobj = SWIG_Py_Void();
46574 return resultobj;
46575 fail:
46576 return NULL;
46577 }
46578
46579
46580 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46581 PyObject *obj;
46582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46583 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46584 return SWIG_Py_Void();
46585 }
46586
46587 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46588 return SWIG_Python_InitShadowInstance(args);
46589 }
46590
46591 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46592 PyObject *resultobj = 0;
46593 wxSizer *arg1 = (wxSizer *) 0 ;
46594 void *argp1 = 0 ;
46595 int res1 = 0 ;
46596 PyObject *swig_obj[1] ;
46597
46598 if (!args) SWIG_fail;
46599 swig_obj[0] = args;
46600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46601 if (!SWIG_IsOK(res1)) {
46602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46603 }
46604 arg1 = reinterpret_cast< wxSizer * >(argp1);
46605 {
46606 PyThreadState* __tstate = wxPyBeginAllowThreads();
46607 delete arg1;
46608
46609 wxPyEndAllowThreads(__tstate);
46610 if (PyErr_Occurred()) SWIG_fail;
46611 }
46612 resultobj = SWIG_Py_Void();
46613 return resultobj;
46614 fail:
46615 return NULL;
46616 }
46617
46618
46619 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46620 PyObject *resultobj = 0;
46621 wxSizer *arg1 = (wxSizer *) 0 ;
46622 PyObject *arg2 = (PyObject *) 0 ;
46623 void *argp1 = 0 ;
46624 int res1 = 0 ;
46625 PyObject * obj0 = 0 ;
46626 PyObject * obj1 = 0 ;
46627 char * kwnames[] = {
46628 (char *) "self",(char *) "_self", NULL
46629 };
46630
46631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46633 if (!SWIG_IsOK(res1)) {
46634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46635 }
46636 arg1 = reinterpret_cast< wxSizer * >(argp1);
46637 arg2 = obj1;
46638 {
46639 PyThreadState* __tstate = wxPyBeginAllowThreads();
46640 wxSizer__setOORInfo(arg1,arg2);
46641 wxPyEndAllowThreads(__tstate);
46642 if (PyErr_Occurred()) SWIG_fail;
46643 }
46644 resultobj = SWIG_Py_Void();
46645 return resultobj;
46646 fail:
46647 return NULL;
46648 }
46649
46650
46651 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46652 PyObject *resultobj = 0;
46653 wxSizer *arg1 = (wxSizer *) 0 ;
46654 PyObject *arg2 = (PyObject *) 0 ;
46655 int arg3 = (int) 0 ;
46656 int arg4 = (int) 0 ;
46657 int arg5 = (int) 0 ;
46658 PyObject *arg6 = (PyObject *) NULL ;
46659 wxSizerItem *result = 0 ;
46660 void *argp1 = 0 ;
46661 int res1 = 0 ;
46662 int val3 ;
46663 int ecode3 = 0 ;
46664 int val4 ;
46665 int ecode4 = 0 ;
46666 int val5 ;
46667 int ecode5 = 0 ;
46668 PyObject * obj0 = 0 ;
46669 PyObject * obj1 = 0 ;
46670 PyObject * obj2 = 0 ;
46671 PyObject * obj3 = 0 ;
46672 PyObject * obj4 = 0 ;
46673 PyObject * obj5 = 0 ;
46674 char * kwnames[] = {
46675 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46676 };
46677
46678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46680 if (!SWIG_IsOK(res1)) {
46681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46682 }
46683 arg1 = reinterpret_cast< wxSizer * >(argp1);
46684 arg2 = obj1;
46685 if (obj2) {
46686 ecode3 = SWIG_AsVal_int(obj2, &val3);
46687 if (!SWIG_IsOK(ecode3)) {
46688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46689 }
46690 arg3 = static_cast< int >(val3);
46691 }
46692 if (obj3) {
46693 ecode4 = SWIG_AsVal_int(obj3, &val4);
46694 if (!SWIG_IsOK(ecode4)) {
46695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46696 }
46697 arg4 = static_cast< int >(val4);
46698 }
46699 if (obj4) {
46700 ecode5 = SWIG_AsVal_int(obj4, &val5);
46701 if (!SWIG_IsOK(ecode5)) {
46702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46703 }
46704 arg5 = static_cast< int >(val5);
46705 }
46706 if (obj5) {
46707 arg6 = obj5;
46708 }
46709 {
46710 PyThreadState* __tstate = wxPyBeginAllowThreads();
46711 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46712 wxPyEndAllowThreads(__tstate);
46713 if (PyErr_Occurred()) SWIG_fail;
46714 }
46715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46716 return resultobj;
46717 fail:
46718 return NULL;
46719 }
46720
46721
46722 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46723 PyObject *resultobj = 0;
46724 wxSizer *arg1 = (wxSizer *) 0 ;
46725 int arg2 ;
46726 PyObject *arg3 = (PyObject *) 0 ;
46727 int arg4 = (int) 0 ;
46728 int arg5 = (int) 0 ;
46729 int arg6 = (int) 0 ;
46730 PyObject *arg7 = (PyObject *) NULL ;
46731 wxSizerItem *result = 0 ;
46732 void *argp1 = 0 ;
46733 int res1 = 0 ;
46734 int val2 ;
46735 int ecode2 = 0 ;
46736 int val4 ;
46737 int ecode4 = 0 ;
46738 int val5 ;
46739 int ecode5 = 0 ;
46740 int val6 ;
46741 int ecode6 = 0 ;
46742 PyObject * obj0 = 0 ;
46743 PyObject * obj1 = 0 ;
46744 PyObject * obj2 = 0 ;
46745 PyObject * obj3 = 0 ;
46746 PyObject * obj4 = 0 ;
46747 PyObject * obj5 = 0 ;
46748 PyObject * obj6 = 0 ;
46749 char * kwnames[] = {
46750 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46751 };
46752
46753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46757 }
46758 arg1 = reinterpret_cast< wxSizer * >(argp1);
46759 ecode2 = SWIG_AsVal_int(obj1, &val2);
46760 if (!SWIG_IsOK(ecode2)) {
46761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46762 }
46763 arg2 = static_cast< int >(val2);
46764 arg3 = obj2;
46765 if (obj3) {
46766 ecode4 = SWIG_AsVal_int(obj3, &val4);
46767 if (!SWIG_IsOK(ecode4)) {
46768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46769 }
46770 arg4 = static_cast< int >(val4);
46771 }
46772 if (obj4) {
46773 ecode5 = SWIG_AsVal_int(obj4, &val5);
46774 if (!SWIG_IsOK(ecode5)) {
46775 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46776 }
46777 arg5 = static_cast< int >(val5);
46778 }
46779 if (obj5) {
46780 ecode6 = SWIG_AsVal_int(obj5, &val6);
46781 if (!SWIG_IsOK(ecode6)) {
46782 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46783 }
46784 arg6 = static_cast< int >(val6);
46785 }
46786 if (obj6) {
46787 arg7 = obj6;
46788 }
46789 {
46790 PyThreadState* __tstate = wxPyBeginAllowThreads();
46791 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46792 wxPyEndAllowThreads(__tstate);
46793 if (PyErr_Occurred()) SWIG_fail;
46794 }
46795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46796 return resultobj;
46797 fail:
46798 return NULL;
46799 }
46800
46801
46802 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46803 PyObject *resultobj = 0;
46804 wxSizer *arg1 = (wxSizer *) 0 ;
46805 PyObject *arg2 = (PyObject *) 0 ;
46806 int arg3 = (int) 0 ;
46807 int arg4 = (int) 0 ;
46808 int arg5 = (int) 0 ;
46809 PyObject *arg6 = (PyObject *) NULL ;
46810 wxSizerItem *result = 0 ;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 int val3 ;
46814 int ecode3 = 0 ;
46815 int val4 ;
46816 int ecode4 = 0 ;
46817 int val5 ;
46818 int ecode5 = 0 ;
46819 PyObject * obj0 = 0 ;
46820 PyObject * obj1 = 0 ;
46821 PyObject * obj2 = 0 ;
46822 PyObject * obj3 = 0 ;
46823 PyObject * obj4 = 0 ;
46824 PyObject * obj5 = 0 ;
46825 char * kwnames[] = {
46826 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46827 };
46828
46829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46833 }
46834 arg1 = reinterpret_cast< wxSizer * >(argp1);
46835 arg2 = obj1;
46836 if (obj2) {
46837 ecode3 = SWIG_AsVal_int(obj2, &val3);
46838 if (!SWIG_IsOK(ecode3)) {
46839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46840 }
46841 arg3 = static_cast< int >(val3);
46842 }
46843 if (obj3) {
46844 ecode4 = SWIG_AsVal_int(obj3, &val4);
46845 if (!SWIG_IsOK(ecode4)) {
46846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46847 }
46848 arg4 = static_cast< int >(val4);
46849 }
46850 if (obj4) {
46851 ecode5 = SWIG_AsVal_int(obj4, &val5);
46852 if (!SWIG_IsOK(ecode5)) {
46853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46854 }
46855 arg5 = static_cast< int >(val5);
46856 }
46857 if (obj5) {
46858 arg6 = obj5;
46859 }
46860 {
46861 PyThreadState* __tstate = wxPyBeginAllowThreads();
46862 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46863 wxPyEndAllowThreads(__tstate);
46864 if (PyErr_Occurred()) SWIG_fail;
46865 }
46866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46867 return resultobj;
46868 fail:
46869 return NULL;
46870 }
46871
46872
46873 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46874 PyObject *resultobj = 0;
46875 wxSizer *arg1 = (wxSizer *) 0 ;
46876 PyObject *arg2 = (PyObject *) 0 ;
46877 bool result;
46878 void *argp1 = 0 ;
46879 int res1 = 0 ;
46880 PyObject * obj0 = 0 ;
46881 PyObject * obj1 = 0 ;
46882 char * kwnames[] = {
46883 (char *) "self",(char *) "item", NULL
46884 };
46885
46886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46888 if (!SWIG_IsOK(res1)) {
46889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46890 }
46891 arg1 = reinterpret_cast< wxSizer * >(argp1);
46892 arg2 = obj1;
46893 {
46894 PyThreadState* __tstate = wxPyBeginAllowThreads();
46895 result = (bool)wxSizer_Remove(arg1,arg2);
46896 wxPyEndAllowThreads(__tstate);
46897 if (PyErr_Occurred()) SWIG_fail;
46898 }
46899 {
46900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46901 }
46902 return resultobj;
46903 fail:
46904 return NULL;
46905 }
46906
46907
46908 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46909 PyObject *resultobj = 0;
46910 wxSizer *arg1 = (wxSizer *) 0 ;
46911 PyObject *arg2 = (PyObject *) 0 ;
46912 bool result;
46913 void *argp1 = 0 ;
46914 int res1 = 0 ;
46915 PyObject * obj0 = 0 ;
46916 PyObject * obj1 = 0 ;
46917 char * kwnames[] = {
46918 (char *) "self",(char *) "item", NULL
46919 };
46920
46921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46923 if (!SWIG_IsOK(res1)) {
46924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46925 }
46926 arg1 = reinterpret_cast< wxSizer * >(argp1);
46927 arg2 = obj1;
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 result = (bool)wxSizer_Detach(arg1,arg2);
46931 wxPyEndAllowThreads(__tstate);
46932 if (PyErr_Occurred()) SWIG_fail;
46933 }
46934 {
46935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46936 }
46937 return resultobj;
46938 fail:
46939 return NULL;
46940 }
46941
46942
46943 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46944 PyObject *resultobj = 0;
46945 wxSizer *arg1 = (wxSizer *) 0 ;
46946 PyObject *arg2 = (PyObject *) 0 ;
46947 wxSizerItem *result = 0 ;
46948 void *argp1 = 0 ;
46949 int res1 = 0 ;
46950 PyObject * obj0 = 0 ;
46951 PyObject * obj1 = 0 ;
46952 char * kwnames[] = {
46953 (char *) "self",(char *) "item", NULL
46954 };
46955
46956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46958 if (!SWIG_IsOK(res1)) {
46959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46960 }
46961 arg1 = reinterpret_cast< wxSizer * >(argp1);
46962 arg2 = obj1;
46963 {
46964 PyThreadState* __tstate = wxPyBeginAllowThreads();
46965 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46966 wxPyEndAllowThreads(__tstate);
46967 if (PyErr_Occurred()) SWIG_fail;
46968 }
46969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46970 return resultobj;
46971 fail:
46972 return NULL;
46973 }
46974
46975
46976 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46977 PyObject *resultobj = 0;
46978 wxSizer *arg1 = (wxSizer *) 0 ;
46979 PyObject *arg2 = (PyObject *) 0 ;
46980 wxSize *arg3 = 0 ;
46981 void *argp1 = 0 ;
46982 int res1 = 0 ;
46983 wxSize temp3 ;
46984 PyObject * obj0 = 0 ;
46985 PyObject * obj1 = 0 ;
46986 PyObject * obj2 = 0 ;
46987 char * kwnames[] = {
46988 (char *) "self",(char *) "item",(char *) "size", NULL
46989 };
46990
46991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46993 if (!SWIG_IsOK(res1)) {
46994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46995 }
46996 arg1 = reinterpret_cast< wxSizer * >(argp1);
46997 arg2 = obj1;
46998 {
46999 arg3 = &temp3;
47000 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47001 }
47002 {
47003 PyThreadState* __tstate = wxPyBeginAllowThreads();
47004 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47005 wxPyEndAllowThreads(__tstate);
47006 if (PyErr_Occurred()) SWIG_fail;
47007 }
47008 resultobj = SWIG_Py_Void();
47009 return resultobj;
47010 fail:
47011 return NULL;
47012 }
47013
47014
47015 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47016 PyObject *resultobj = 0;
47017 wxSizer *arg1 = (wxSizer *) 0 ;
47018 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47019 wxSizerItem *result = 0 ;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 int res2 = 0 ;
47023 PyObject * obj0 = 0 ;
47024 PyObject * obj1 = 0 ;
47025 char * kwnames[] = {
47026 (char *) "self",(char *) "item", NULL
47027 };
47028
47029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47031 if (!SWIG_IsOK(res1)) {
47032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47033 }
47034 arg1 = reinterpret_cast< wxSizer * >(argp1);
47035 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47036 if (!SWIG_IsOK(res2)) {
47037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47038 }
47039 {
47040 PyThreadState* __tstate = wxPyBeginAllowThreads();
47041 result = (wxSizerItem *)(arg1)->Add(arg2);
47042 wxPyEndAllowThreads(__tstate);
47043 if (PyErr_Occurred()) SWIG_fail;
47044 }
47045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47046 return resultobj;
47047 fail:
47048 return NULL;
47049 }
47050
47051
47052 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47053 PyObject *resultobj = 0;
47054 wxSizer *arg1 = (wxSizer *) 0 ;
47055 size_t arg2 ;
47056 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47057 wxSizerItem *result = 0 ;
47058 void *argp1 = 0 ;
47059 int res1 = 0 ;
47060 size_t val2 ;
47061 int ecode2 = 0 ;
47062 int res3 = 0 ;
47063 PyObject * obj0 = 0 ;
47064 PyObject * obj1 = 0 ;
47065 PyObject * obj2 = 0 ;
47066 char * kwnames[] = {
47067 (char *) "self",(char *) "index",(char *) "item", NULL
47068 };
47069
47070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47072 if (!SWIG_IsOK(res1)) {
47073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47074 }
47075 arg1 = reinterpret_cast< wxSizer * >(argp1);
47076 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47077 if (!SWIG_IsOK(ecode2)) {
47078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47079 }
47080 arg2 = static_cast< size_t >(val2);
47081 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47082 if (!SWIG_IsOK(res3)) {
47083 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47084 }
47085 {
47086 PyThreadState* __tstate = wxPyBeginAllowThreads();
47087 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47088 wxPyEndAllowThreads(__tstate);
47089 if (PyErr_Occurred()) SWIG_fail;
47090 }
47091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47092 return resultobj;
47093 fail:
47094 return NULL;
47095 }
47096
47097
47098 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47099 PyObject *resultobj = 0;
47100 wxSizer *arg1 = (wxSizer *) 0 ;
47101 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47102 wxSizerItem *result = 0 ;
47103 void *argp1 = 0 ;
47104 int res1 = 0 ;
47105 int res2 = 0 ;
47106 PyObject * obj0 = 0 ;
47107 PyObject * obj1 = 0 ;
47108 char * kwnames[] = {
47109 (char *) "self",(char *) "item", NULL
47110 };
47111
47112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47114 if (!SWIG_IsOK(res1)) {
47115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47116 }
47117 arg1 = reinterpret_cast< wxSizer * >(argp1);
47118 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47119 if (!SWIG_IsOK(res2)) {
47120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47121 }
47122 {
47123 PyThreadState* __tstate = wxPyBeginAllowThreads();
47124 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47125 wxPyEndAllowThreads(__tstate);
47126 if (PyErr_Occurred()) SWIG_fail;
47127 }
47128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47129 return resultobj;
47130 fail:
47131 return NULL;
47132 }
47133
47134
47135 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47136 PyObject *resultobj = 0;
47137 wxSizer *arg1 = (wxSizer *) 0 ;
47138 int arg2 ;
47139 int arg3 ;
47140 int arg4 ;
47141 int arg5 ;
47142 void *argp1 = 0 ;
47143 int res1 = 0 ;
47144 int val2 ;
47145 int ecode2 = 0 ;
47146 int val3 ;
47147 int ecode3 = 0 ;
47148 int val4 ;
47149 int ecode4 = 0 ;
47150 int val5 ;
47151 int ecode5 = 0 ;
47152 PyObject * obj0 = 0 ;
47153 PyObject * obj1 = 0 ;
47154 PyObject * obj2 = 0 ;
47155 PyObject * obj3 = 0 ;
47156 PyObject * obj4 = 0 ;
47157 char * kwnames[] = {
47158 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47159 };
47160
47161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47163 if (!SWIG_IsOK(res1)) {
47164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47165 }
47166 arg1 = reinterpret_cast< wxSizer * >(argp1);
47167 ecode2 = SWIG_AsVal_int(obj1, &val2);
47168 if (!SWIG_IsOK(ecode2)) {
47169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47170 }
47171 arg2 = static_cast< int >(val2);
47172 ecode3 = SWIG_AsVal_int(obj2, &val3);
47173 if (!SWIG_IsOK(ecode3)) {
47174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47175 }
47176 arg3 = static_cast< int >(val3);
47177 ecode4 = SWIG_AsVal_int(obj3, &val4);
47178 if (!SWIG_IsOK(ecode4)) {
47179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47180 }
47181 arg4 = static_cast< int >(val4);
47182 ecode5 = SWIG_AsVal_int(obj4, &val5);
47183 if (!SWIG_IsOK(ecode5)) {
47184 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47185 }
47186 arg5 = static_cast< int >(val5);
47187 {
47188 PyThreadState* __tstate = wxPyBeginAllowThreads();
47189 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47190 wxPyEndAllowThreads(__tstate);
47191 if (PyErr_Occurred()) SWIG_fail;
47192 }
47193 resultobj = SWIG_Py_Void();
47194 return resultobj;
47195 fail:
47196 return NULL;
47197 }
47198
47199
47200 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47201 PyObject *resultobj = 0;
47202 wxSizer *arg1 = (wxSizer *) 0 ;
47203 wxSize *arg2 = 0 ;
47204 void *argp1 = 0 ;
47205 int res1 = 0 ;
47206 wxSize temp2 ;
47207 PyObject * obj0 = 0 ;
47208 PyObject * obj1 = 0 ;
47209 char * kwnames[] = {
47210 (char *) "self",(char *) "size", NULL
47211 };
47212
47213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47215 if (!SWIG_IsOK(res1)) {
47216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47217 }
47218 arg1 = reinterpret_cast< wxSizer * >(argp1);
47219 {
47220 arg2 = &temp2;
47221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47222 }
47223 {
47224 PyThreadState* __tstate = wxPyBeginAllowThreads();
47225 (arg1)->SetMinSize((wxSize const &)*arg2);
47226 wxPyEndAllowThreads(__tstate);
47227 if (PyErr_Occurred()) SWIG_fail;
47228 }
47229 resultobj = SWIG_Py_Void();
47230 return resultobj;
47231 fail:
47232 return NULL;
47233 }
47234
47235
47236 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47237 PyObject *resultobj = 0;
47238 wxSizer *arg1 = (wxSizer *) 0 ;
47239 wxSize result;
47240 void *argp1 = 0 ;
47241 int res1 = 0 ;
47242 PyObject *swig_obj[1] ;
47243
47244 if (!args) SWIG_fail;
47245 swig_obj[0] = args;
47246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47247 if (!SWIG_IsOK(res1)) {
47248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47249 }
47250 arg1 = reinterpret_cast< wxSizer * >(argp1);
47251 {
47252 PyThreadState* __tstate = wxPyBeginAllowThreads();
47253 result = (arg1)->GetSize();
47254 wxPyEndAllowThreads(__tstate);
47255 if (PyErr_Occurred()) SWIG_fail;
47256 }
47257 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47258 return resultobj;
47259 fail:
47260 return NULL;
47261 }
47262
47263
47264 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47265 PyObject *resultobj = 0;
47266 wxSizer *arg1 = (wxSizer *) 0 ;
47267 wxPoint result;
47268 void *argp1 = 0 ;
47269 int res1 = 0 ;
47270 PyObject *swig_obj[1] ;
47271
47272 if (!args) SWIG_fail;
47273 swig_obj[0] = args;
47274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47275 if (!SWIG_IsOK(res1)) {
47276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47277 }
47278 arg1 = reinterpret_cast< wxSizer * >(argp1);
47279 {
47280 PyThreadState* __tstate = wxPyBeginAllowThreads();
47281 result = (arg1)->GetPosition();
47282 wxPyEndAllowThreads(__tstate);
47283 if (PyErr_Occurred()) SWIG_fail;
47284 }
47285 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47286 return resultobj;
47287 fail:
47288 return NULL;
47289 }
47290
47291
47292 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47293 PyObject *resultobj = 0;
47294 wxSizer *arg1 = (wxSizer *) 0 ;
47295 wxSize result;
47296 void *argp1 = 0 ;
47297 int res1 = 0 ;
47298 PyObject *swig_obj[1] ;
47299
47300 if (!args) SWIG_fail;
47301 swig_obj[0] = args;
47302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47303 if (!SWIG_IsOK(res1)) {
47304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47305 }
47306 arg1 = reinterpret_cast< wxSizer * >(argp1);
47307 {
47308 PyThreadState* __tstate = wxPyBeginAllowThreads();
47309 result = (arg1)->GetMinSize();
47310 wxPyEndAllowThreads(__tstate);
47311 if (PyErr_Occurred()) SWIG_fail;
47312 }
47313 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47314 return resultobj;
47315 fail:
47316 return NULL;
47317 }
47318
47319
47320 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47321 PyObject *resultobj = 0;
47322 wxSizer *arg1 = (wxSizer *) 0 ;
47323 void *argp1 = 0 ;
47324 int res1 = 0 ;
47325 PyObject *swig_obj[1] ;
47326
47327 if (!args) SWIG_fail;
47328 swig_obj[0] = args;
47329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47330 if (!SWIG_IsOK(res1)) {
47331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47332 }
47333 arg1 = reinterpret_cast< wxSizer * >(argp1);
47334 {
47335 PyThreadState* __tstate = wxPyBeginAllowThreads();
47336 (arg1)->RecalcSizes();
47337 wxPyEndAllowThreads(__tstate);
47338 if (PyErr_Occurred()) SWIG_fail;
47339 }
47340 resultobj = SWIG_Py_Void();
47341 return resultobj;
47342 fail:
47343 return NULL;
47344 }
47345
47346
47347 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47348 PyObject *resultobj = 0;
47349 wxSizer *arg1 = (wxSizer *) 0 ;
47350 wxSize result;
47351 void *argp1 = 0 ;
47352 int res1 = 0 ;
47353 PyObject *swig_obj[1] ;
47354
47355 if (!args) SWIG_fail;
47356 swig_obj[0] = args;
47357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47358 if (!SWIG_IsOK(res1)) {
47359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47360 }
47361 arg1 = reinterpret_cast< wxSizer * >(argp1);
47362 {
47363 PyThreadState* __tstate = wxPyBeginAllowThreads();
47364 result = (arg1)->CalcMin();
47365 wxPyEndAllowThreads(__tstate);
47366 if (PyErr_Occurred()) SWIG_fail;
47367 }
47368 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47369 return resultobj;
47370 fail:
47371 return NULL;
47372 }
47373
47374
47375 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47376 PyObject *resultobj = 0;
47377 wxSizer *arg1 = (wxSizer *) 0 ;
47378 void *argp1 = 0 ;
47379 int res1 = 0 ;
47380 PyObject *swig_obj[1] ;
47381
47382 if (!args) SWIG_fail;
47383 swig_obj[0] = args;
47384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47385 if (!SWIG_IsOK(res1)) {
47386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47387 }
47388 arg1 = reinterpret_cast< wxSizer * >(argp1);
47389 {
47390 PyThreadState* __tstate = wxPyBeginAllowThreads();
47391 (arg1)->Layout();
47392 wxPyEndAllowThreads(__tstate);
47393 if (PyErr_Occurred()) SWIG_fail;
47394 }
47395 resultobj = SWIG_Py_Void();
47396 return resultobj;
47397 fail:
47398 return NULL;
47399 }
47400
47401
47402 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47403 PyObject *resultobj = 0;
47404 wxSizer *arg1 = (wxSizer *) 0 ;
47405 wxWindow *arg2 = (wxWindow *) 0 ;
47406 wxSize result;
47407 void *argp1 = 0 ;
47408 int res1 = 0 ;
47409 void *argp2 = 0 ;
47410 int res2 = 0 ;
47411 PyObject * obj0 = 0 ;
47412 PyObject * obj1 = 0 ;
47413 char * kwnames[] = {
47414 (char *) "self",(char *) "window", NULL
47415 };
47416
47417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47419 if (!SWIG_IsOK(res1)) {
47420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47421 }
47422 arg1 = reinterpret_cast< wxSizer * >(argp1);
47423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47424 if (!SWIG_IsOK(res2)) {
47425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47426 }
47427 arg2 = reinterpret_cast< wxWindow * >(argp2);
47428 {
47429 PyThreadState* __tstate = wxPyBeginAllowThreads();
47430 result = (arg1)->Fit(arg2);
47431 wxPyEndAllowThreads(__tstate);
47432 if (PyErr_Occurred()) SWIG_fail;
47433 }
47434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47435 return resultobj;
47436 fail:
47437 return NULL;
47438 }
47439
47440
47441 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47442 PyObject *resultobj = 0;
47443 wxSizer *arg1 = (wxSizer *) 0 ;
47444 wxWindow *arg2 = (wxWindow *) 0 ;
47445 void *argp1 = 0 ;
47446 int res1 = 0 ;
47447 void *argp2 = 0 ;
47448 int res2 = 0 ;
47449 PyObject * obj0 = 0 ;
47450 PyObject * obj1 = 0 ;
47451 char * kwnames[] = {
47452 (char *) "self",(char *) "window", NULL
47453 };
47454
47455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47457 if (!SWIG_IsOK(res1)) {
47458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47459 }
47460 arg1 = reinterpret_cast< wxSizer * >(argp1);
47461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47462 if (!SWIG_IsOK(res2)) {
47463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47464 }
47465 arg2 = reinterpret_cast< wxWindow * >(argp2);
47466 {
47467 PyThreadState* __tstate = wxPyBeginAllowThreads();
47468 (arg1)->FitInside(arg2);
47469 wxPyEndAllowThreads(__tstate);
47470 if (PyErr_Occurred()) SWIG_fail;
47471 }
47472 resultobj = SWIG_Py_Void();
47473 return resultobj;
47474 fail:
47475 return NULL;
47476 }
47477
47478
47479 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47480 PyObject *resultobj = 0;
47481 wxSizer *arg1 = (wxSizer *) 0 ;
47482 wxWindow *arg2 = (wxWindow *) 0 ;
47483 void *argp1 = 0 ;
47484 int res1 = 0 ;
47485 void *argp2 = 0 ;
47486 int res2 = 0 ;
47487 PyObject * obj0 = 0 ;
47488 PyObject * obj1 = 0 ;
47489 char * kwnames[] = {
47490 (char *) "self",(char *) "window", NULL
47491 };
47492
47493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47495 if (!SWIG_IsOK(res1)) {
47496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47497 }
47498 arg1 = reinterpret_cast< wxSizer * >(argp1);
47499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47500 if (!SWIG_IsOK(res2)) {
47501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47502 }
47503 arg2 = reinterpret_cast< wxWindow * >(argp2);
47504 {
47505 PyThreadState* __tstate = wxPyBeginAllowThreads();
47506 (arg1)->SetSizeHints(arg2);
47507 wxPyEndAllowThreads(__tstate);
47508 if (PyErr_Occurred()) SWIG_fail;
47509 }
47510 resultobj = SWIG_Py_Void();
47511 return resultobj;
47512 fail:
47513 return NULL;
47514 }
47515
47516
47517 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47518 PyObject *resultobj = 0;
47519 wxSizer *arg1 = (wxSizer *) 0 ;
47520 wxWindow *arg2 = (wxWindow *) 0 ;
47521 void *argp1 = 0 ;
47522 int res1 = 0 ;
47523 void *argp2 = 0 ;
47524 int res2 = 0 ;
47525 PyObject * obj0 = 0 ;
47526 PyObject * obj1 = 0 ;
47527 char * kwnames[] = {
47528 (char *) "self",(char *) "window", NULL
47529 };
47530
47531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47533 if (!SWIG_IsOK(res1)) {
47534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47535 }
47536 arg1 = reinterpret_cast< wxSizer * >(argp1);
47537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47538 if (!SWIG_IsOK(res2)) {
47539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47540 }
47541 arg2 = reinterpret_cast< wxWindow * >(argp2);
47542 {
47543 PyThreadState* __tstate = wxPyBeginAllowThreads();
47544 (arg1)->SetVirtualSizeHints(arg2);
47545 wxPyEndAllowThreads(__tstate);
47546 if (PyErr_Occurred()) SWIG_fail;
47547 }
47548 resultobj = SWIG_Py_Void();
47549 return resultobj;
47550 fail:
47551 return NULL;
47552 }
47553
47554
47555 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47556 PyObject *resultobj = 0;
47557 wxSizer *arg1 = (wxSizer *) 0 ;
47558 bool arg2 = (bool) false ;
47559 void *argp1 = 0 ;
47560 int res1 = 0 ;
47561 bool val2 ;
47562 int ecode2 = 0 ;
47563 PyObject * obj0 = 0 ;
47564 PyObject * obj1 = 0 ;
47565 char * kwnames[] = {
47566 (char *) "self",(char *) "deleteWindows", NULL
47567 };
47568
47569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47571 if (!SWIG_IsOK(res1)) {
47572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47573 }
47574 arg1 = reinterpret_cast< wxSizer * >(argp1);
47575 if (obj1) {
47576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47577 if (!SWIG_IsOK(ecode2)) {
47578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47579 }
47580 arg2 = static_cast< bool >(val2);
47581 }
47582 {
47583 PyThreadState* __tstate = wxPyBeginAllowThreads();
47584 (arg1)->Clear(arg2);
47585 wxPyEndAllowThreads(__tstate);
47586 if (PyErr_Occurred()) SWIG_fail;
47587 }
47588 resultobj = SWIG_Py_Void();
47589 return resultobj;
47590 fail:
47591 return NULL;
47592 }
47593
47594
47595 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47596 PyObject *resultobj = 0;
47597 wxSizer *arg1 = (wxSizer *) 0 ;
47598 void *argp1 = 0 ;
47599 int res1 = 0 ;
47600 PyObject *swig_obj[1] ;
47601
47602 if (!args) SWIG_fail;
47603 swig_obj[0] = args;
47604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47605 if (!SWIG_IsOK(res1)) {
47606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47607 }
47608 arg1 = reinterpret_cast< wxSizer * >(argp1);
47609 {
47610 PyThreadState* __tstate = wxPyBeginAllowThreads();
47611 (arg1)->DeleteWindows();
47612 wxPyEndAllowThreads(__tstate);
47613 if (PyErr_Occurred()) SWIG_fail;
47614 }
47615 resultobj = SWIG_Py_Void();
47616 return resultobj;
47617 fail:
47618 return NULL;
47619 }
47620
47621
47622 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47623 PyObject *resultobj = 0;
47624 wxSizer *arg1 = (wxSizer *) 0 ;
47625 PyObject *result = 0 ;
47626 void *argp1 = 0 ;
47627 int res1 = 0 ;
47628 PyObject *swig_obj[1] ;
47629
47630 if (!args) SWIG_fail;
47631 swig_obj[0] = args;
47632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47633 if (!SWIG_IsOK(res1)) {
47634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47635 }
47636 arg1 = reinterpret_cast< wxSizer * >(argp1);
47637 {
47638 PyThreadState* __tstate = wxPyBeginAllowThreads();
47639 result = (PyObject *)wxSizer_GetChildren(arg1);
47640 wxPyEndAllowThreads(__tstate);
47641 if (PyErr_Occurred()) SWIG_fail;
47642 }
47643 resultobj = result;
47644 return resultobj;
47645 fail:
47646 return NULL;
47647 }
47648
47649
47650 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47651 PyObject *resultobj = 0;
47652 wxSizer *arg1 = (wxSizer *) 0 ;
47653 PyObject *arg2 = (PyObject *) 0 ;
47654 bool arg3 = (bool) true ;
47655 bool arg4 = (bool) false ;
47656 bool result;
47657 void *argp1 = 0 ;
47658 int res1 = 0 ;
47659 bool val3 ;
47660 int ecode3 = 0 ;
47661 bool val4 ;
47662 int ecode4 = 0 ;
47663 PyObject * obj0 = 0 ;
47664 PyObject * obj1 = 0 ;
47665 PyObject * obj2 = 0 ;
47666 PyObject * obj3 = 0 ;
47667 char * kwnames[] = {
47668 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47669 };
47670
47671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47673 if (!SWIG_IsOK(res1)) {
47674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47675 }
47676 arg1 = reinterpret_cast< wxSizer * >(argp1);
47677 arg2 = obj1;
47678 if (obj2) {
47679 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47680 if (!SWIG_IsOK(ecode3)) {
47681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47682 }
47683 arg3 = static_cast< bool >(val3);
47684 }
47685 if (obj3) {
47686 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47687 if (!SWIG_IsOK(ecode4)) {
47688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47689 }
47690 arg4 = static_cast< bool >(val4);
47691 }
47692 {
47693 PyThreadState* __tstate = wxPyBeginAllowThreads();
47694 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47695 wxPyEndAllowThreads(__tstate);
47696 if (PyErr_Occurred()) SWIG_fail;
47697 }
47698 {
47699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47700 }
47701 return resultobj;
47702 fail:
47703 return NULL;
47704 }
47705
47706
47707 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47708 PyObject *resultobj = 0;
47709 wxSizer *arg1 = (wxSizer *) 0 ;
47710 PyObject *arg2 = (PyObject *) 0 ;
47711 bool result;
47712 void *argp1 = 0 ;
47713 int res1 = 0 ;
47714 PyObject * obj0 = 0 ;
47715 PyObject * obj1 = 0 ;
47716 char * kwnames[] = {
47717 (char *) "self",(char *) "item", NULL
47718 };
47719
47720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47722 if (!SWIG_IsOK(res1)) {
47723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47724 }
47725 arg1 = reinterpret_cast< wxSizer * >(argp1);
47726 arg2 = obj1;
47727 {
47728 PyThreadState* __tstate = wxPyBeginAllowThreads();
47729 result = (bool)wxSizer_IsShown(arg1,arg2);
47730 wxPyEndAllowThreads(__tstate);
47731 if (PyErr_Occurred()) SWIG_fail;
47732 }
47733 {
47734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47735 }
47736 return resultobj;
47737 fail:
47738 return NULL;
47739 }
47740
47741
47742 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47743 PyObject *resultobj = 0;
47744 wxSizer *arg1 = (wxSizer *) 0 ;
47745 bool arg2 ;
47746 void *argp1 = 0 ;
47747 int res1 = 0 ;
47748 bool val2 ;
47749 int ecode2 = 0 ;
47750 PyObject * obj0 = 0 ;
47751 PyObject * obj1 = 0 ;
47752 char * kwnames[] = {
47753 (char *) "self",(char *) "show", NULL
47754 };
47755
47756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47758 if (!SWIG_IsOK(res1)) {
47759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47760 }
47761 arg1 = reinterpret_cast< wxSizer * >(argp1);
47762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47763 if (!SWIG_IsOK(ecode2)) {
47764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47765 }
47766 arg2 = static_cast< bool >(val2);
47767 {
47768 PyThreadState* __tstate = wxPyBeginAllowThreads();
47769 (arg1)->ShowItems(arg2);
47770 wxPyEndAllowThreads(__tstate);
47771 if (PyErr_Occurred()) SWIG_fail;
47772 }
47773 resultobj = SWIG_Py_Void();
47774 return resultobj;
47775 fail:
47776 return NULL;
47777 }
47778
47779
47780 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47781 PyObject *obj;
47782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47783 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47784 return SWIG_Py_Void();
47785 }
47786
47787 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47788 PyObject *resultobj = 0;
47789 wxPySizer *result = 0 ;
47790
47791 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47792 {
47793 PyThreadState* __tstate = wxPyBeginAllowThreads();
47794 result = (wxPySizer *)new wxPySizer();
47795 wxPyEndAllowThreads(__tstate);
47796 if (PyErr_Occurred()) SWIG_fail;
47797 }
47798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47799 return resultobj;
47800 fail:
47801 return NULL;
47802 }
47803
47804
47805 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47806 PyObject *resultobj = 0;
47807 wxPySizer *arg1 = (wxPySizer *) 0 ;
47808 PyObject *arg2 = (PyObject *) 0 ;
47809 PyObject *arg3 = (PyObject *) 0 ;
47810 void *argp1 = 0 ;
47811 int res1 = 0 ;
47812 PyObject * obj0 = 0 ;
47813 PyObject * obj1 = 0 ;
47814 PyObject * obj2 = 0 ;
47815 char * kwnames[] = {
47816 (char *) "self",(char *) "self",(char *) "_class", NULL
47817 };
47818
47819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47821 if (!SWIG_IsOK(res1)) {
47822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47823 }
47824 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47825 arg2 = obj1;
47826 arg3 = obj2;
47827 {
47828 PyThreadState* __tstate = wxPyBeginAllowThreads();
47829 (arg1)->_setCallbackInfo(arg2,arg3);
47830 wxPyEndAllowThreads(__tstate);
47831 if (PyErr_Occurred()) SWIG_fail;
47832 }
47833 resultobj = SWIG_Py_Void();
47834 return resultobj;
47835 fail:
47836 return NULL;
47837 }
47838
47839
47840 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47841 PyObject *obj;
47842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47843 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47844 return SWIG_Py_Void();
47845 }
47846
47847 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47848 return SWIG_Python_InitShadowInstance(args);
47849 }
47850
47851 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47852 PyObject *resultobj = 0;
47853 int arg1 = (int) wxHORIZONTAL ;
47854 wxBoxSizer *result = 0 ;
47855 int val1 ;
47856 int ecode1 = 0 ;
47857 PyObject * obj0 = 0 ;
47858 char * kwnames[] = {
47859 (char *) "orient", NULL
47860 };
47861
47862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47863 if (obj0) {
47864 ecode1 = SWIG_AsVal_int(obj0, &val1);
47865 if (!SWIG_IsOK(ecode1)) {
47866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47867 }
47868 arg1 = static_cast< int >(val1);
47869 }
47870 {
47871 PyThreadState* __tstate = wxPyBeginAllowThreads();
47872 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47873 wxPyEndAllowThreads(__tstate);
47874 if (PyErr_Occurred()) SWIG_fail;
47875 }
47876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47877 return resultobj;
47878 fail:
47879 return NULL;
47880 }
47881
47882
47883 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47884 PyObject *resultobj = 0;
47885 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47886 int result;
47887 void *argp1 = 0 ;
47888 int res1 = 0 ;
47889 PyObject *swig_obj[1] ;
47890
47891 if (!args) SWIG_fail;
47892 swig_obj[0] = args;
47893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47894 if (!SWIG_IsOK(res1)) {
47895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47896 }
47897 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47898 {
47899 PyThreadState* __tstate = wxPyBeginAllowThreads();
47900 result = (int)(arg1)->GetOrientation();
47901 wxPyEndAllowThreads(__tstate);
47902 if (PyErr_Occurred()) SWIG_fail;
47903 }
47904 resultobj = SWIG_From_int(static_cast< int >(result));
47905 return resultobj;
47906 fail:
47907 return NULL;
47908 }
47909
47910
47911 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47912 PyObject *resultobj = 0;
47913 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47914 int arg2 ;
47915 void *argp1 = 0 ;
47916 int res1 = 0 ;
47917 int val2 ;
47918 int ecode2 = 0 ;
47919 PyObject * obj0 = 0 ;
47920 PyObject * obj1 = 0 ;
47921 char * kwnames[] = {
47922 (char *) "self",(char *) "orient", NULL
47923 };
47924
47925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47929 }
47930 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47931 ecode2 = SWIG_AsVal_int(obj1, &val2);
47932 if (!SWIG_IsOK(ecode2)) {
47933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47934 }
47935 arg2 = static_cast< int >(val2);
47936 {
47937 PyThreadState* __tstate = wxPyBeginAllowThreads();
47938 (arg1)->SetOrientation(arg2);
47939 wxPyEndAllowThreads(__tstate);
47940 if (PyErr_Occurred()) SWIG_fail;
47941 }
47942 resultobj = SWIG_Py_Void();
47943 return resultobj;
47944 fail:
47945 return NULL;
47946 }
47947
47948
47949 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47950 PyObject *obj;
47951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47952 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47953 return SWIG_Py_Void();
47954 }
47955
47956 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47957 return SWIG_Python_InitShadowInstance(args);
47958 }
47959
47960 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47961 PyObject *resultobj = 0;
47962 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47963 int arg2 = (int) wxHORIZONTAL ;
47964 wxStaticBoxSizer *result = 0 ;
47965 void *argp1 = 0 ;
47966 int res1 = 0 ;
47967 int val2 ;
47968 int ecode2 = 0 ;
47969 PyObject * obj0 = 0 ;
47970 PyObject * obj1 = 0 ;
47971 char * kwnames[] = {
47972 (char *) "box",(char *) "orient", NULL
47973 };
47974
47975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47977 if (!SWIG_IsOK(res1)) {
47978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47979 }
47980 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47981 if (obj1) {
47982 ecode2 = SWIG_AsVal_int(obj1, &val2);
47983 if (!SWIG_IsOK(ecode2)) {
47984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47985 }
47986 arg2 = static_cast< int >(val2);
47987 }
47988 {
47989 PyThreadState* __tstate = wxPyBeginAllowThreads();
47990 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47991 wxPyEndAllowThreads(__tstate);
47992 if (PyErr_Occurred()) SWIG_fail;
47993 }
47994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47995 return resultobj;
47996 fail:
47997 return NULL;
47998 }
47999
48000
48001 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48002 PyObject *resultobj = 0;
48003 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48004 wxStaticBox *result = 0 ;
48005 void *argp1 = 0 ;
48006 int res1 = 0 ;
48007 PyObject *swig_obj[1] ;
48008
48009 if (!args) SWIG_fail;
48010 swig_obj[0] = args;
48011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48012 if (!SWIG_IsOK(res1)) {
48013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48014 }
48015 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48016 {
48017 PyThreadState* __tstate = wxPyBeginAllowThreads();
48018 result = (wxStaticBox *)(arg1)->GetStaticBox();
48019 wxPyEndAllowThreads(__tstate);
48020 if (PyErr_Occurred()) SWIG_fail;
48021 }
48022 {
48023 resultobj = wxPyMake_wxObject(result, (bool)0);
48024 }
48025 return resultobj;
48026 fail:
48027 return NULL;
48028 }
48029
48030
48031 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48032 PyObject *obj;
48033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48034 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48035 return SWIG_Py_Void();
48036 }
48037
48038 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48039 return SWIG_Python_InitShadowInstance(args);
48040 }
48041
48042 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48043 PyObject *resultobj = 0;
48044 int arg1 = (int) 1 ;
48045 int arg2 = (int) 0 ;
48046 int arg3 = (int) 0 ;
48047 int arg4 = (int) 0 ;
48048 wxGridSizer *result = 0 ;
48049 int val1 ;
48050 int ecode1 = 0 ;
48051 int val2 ;
48052 int ecode2 = 0 ;
48053 int val3 ;
48054 int ecode3 = 0 ;
48055 int val4 ;
48056 int ecode4 = 0 ;
48057 PyObject * obj0 = 0 ;
48058 PyObject * obj1 = 0 ;
48059 PyObject * obj2 = 0 ;
48060 PyObject * obj3 = 0 ;
48061 char * kwnames[] = {
48062 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48063 };
48064
48065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48066 if (obj0) {
48067 ecode1 = SWIG_AsVal_int(obj0, &val1);
48068 if (!SWIG_IsOK(ecode1)) {
48069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48070 }
48071 arg1 = static_cast< int >(val1);
48072 }
48073 if (obj1) {
48074 ecode2 = SWIG_AsVal_int(obj1, &val2);
48075 if (!SWIG_IsOK(ecode2)) {
48076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48077 }
48078 arg2 = static_cast< int >(val2);
48079 }
48080 if (obj2) {
48081 ecode3 = SWIG_AsVal_int(obj2, &val3);
48082 if (!SWIG_IsOK(ecode3)) {
48083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48084 }
48085 arg3 = static_cast< int >(val3);
48086 }
48087 if (obj3) {
48088 ecode4 = SWIG_AsVal_int(obj3, &val4);
48089 if (!SWIG_IsOK(ecode4)) {
48090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48091 }
48092 arg4 = static_cast< int >(val4);
48093 }
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48101 return resultobj;
48102 fail:
48103 return NULL;
48104 }
48105
48106
48107 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48108 PyObject *resultobj = 0;
48109 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48110 int arg2 ;
48111 void *argp1 = 0 ;
48112 int res1 = 0 ;
48113 int val2 ;
48114 int ecode2 = 0 ;
48115 PyObject * obj0 = 0 ;
48116 PyObject * obj1 = 0 ;
48117 char * kwnames[] = {
48118 (char *) "self",(char *) "cols", NULL
48119 };
48120
48121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48123 if (!SWIG_IsOK(res1)) {
48124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48125 }
48126 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48127 ecode2 = SWIG_AsVal_int(obj1, &val2);
48128 if (!SWIG_IsOK(ecode2)) {
48129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48130 }
48131 arg2 = static_cast< int >(val2);
48132 {
48133 PyThreadState* __tstate = wxPyBeginAllowThreads();
48134 (arg1)->SetCols(arg2);
48135 wxPyEndAllowThreads(__tstate);
48136 if (PyErr_Occurred()) SWIG_fail;
48137 }
48138 resultobj = SWIG_Py_Void();
48139 return resultobj;
48140 fail:
48141 return NULL;
48142 }
48143
48144
48145 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48146 PyObject *resultobj = 0;
48147 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48148 int arg2 ;
48149 void *argp1 = 0 ;
48150 int res1 = 0 ;
48151 int val2 ;
48152 int ecode2 = 0 ;
48153 PyObject * obj0 = 0 ;
48154 PyObject * obj1 = 0 ;
48155 char * kwnames[] = {
48156 (char *) "self",(char *) "rows", NULL
48157 };
48158
48159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48161 if (!SWIG_IsOK(res1)) {
48162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48163 }
48164 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48165 ecode2 = SWIG_AsVal_int(obj1, &val2);
48166 if (!SWIG_IsOK(ecode2)) {
48167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48168 }
48169 arg2 = static_cast< int >(val2);
48170 {
48171 PyThreadState* __tstate = wxPyBeginAllowThreads();
48172 (arg1)->SetRows(arg2);
48173 wxPyEndAllowThreads(__tstate);
48174 if (PyErr_Occurred()) SWIG_fail;
48175 }
48176 resultobj = SWIG_Py_Void();
48177 return resultobj;
48178 fail:
48179 return NULL;
48180 }
48181
48182
48183 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48184 PyObject *resultobj = 0;
48185 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48186 int arg2 ;
48187 void *argp1 = 0 ;
48188 int res1 = 0 ;
48189 int val2 ;
48190 int ecode2 = 0 ;
48191 PyObject * obj0 = 0 ;
48192 PyObject * obj1 = 0 ;
48193 char * kwnames[] = {
48194 (char *) "self",(char *) "gap", NULL
48195 };
48196
48197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48199 if (!SWIG_IsOK(res1)) {
48200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48201 }
48202 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48203 ecode2 = SWIG_AsVal_int(obj1, &val2);
48204 if (!SWIG_IsOK(ecode2)) {
48205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48206 }
48207 arg2 = static_cast< int >(val2);
48208 {
48209 PyThreadState* __tstate = wxPyBeginAllowThreads();
48210 (arg1)->SetVGap(arg2);
48211 wxPyEndAllowThreads(__tstate);
48212 if (PyErr_Occurred()) SWIG_fail;
48213 }
48214 resultobj = SWIG_Py_Void();
48215 return resultobj;
48216 fail:
48217 return NULL;
48218 }
48219
48220
48221 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48222 PyObject *resultobj = 0;
48223 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48224 int arg2 ;
48225 void *argp1 = 0 ;
48226 int res1 = 0 ;
48227 int val2 ;
48228 int ecode2 = 0 ;
48229 PyObject * obj0 = 0 ;
48230 PyObject * obj1 = 0 ;
48231 char * kwnames[] = {
48232 (char *) "self",(char *) "gap", NULL
48233 };
48234
48235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48237 if (!SWIG_IsOK(res1)) {
48238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48239 }
48240 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48241 ecode2 = SWIG_AsVal_int(obj1, &val2);
48242 if (!SWIG_IsOK(ecode2)) {
48243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48244 }
48245 arg2 = static_cast< int >(val2);
48246 {
48247 PyThreadState* __tstate = wxPyBeginAllowThreads();
48248 (arg1)->SetHGap(arg2);
48249 wxPyEndAllowThreads(__tstate);
48250 if (PyErr_Occurred()) SWIG_fail;
48251 }
48252 resultobj = SWIG_Py_Void();
48253 return resultobj;
48254 fail:
48255 return NULL;
48256 }
48257
48258
48259 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48260 PyObject *resultobj = 0;
48261 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48262 int result;
48263 void *argp1 = 0 ;
48264 int res1 = 0 ;
48265 PyObject *swig_obj[1] ;
48266
48267 if (!args) SWIG_fail;
48268 swig_obj[0] = args;
48269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48270 if (!SWIG_IsOK(res1)) {
48271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48272 }
48273 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48274 {
48275 PyThreadState* __tstate = wxPyBeginAllowThreads();
48276 result = (int)(arg1)->GetCols();
48277 wxPyEndAllowThreads(__tstate);
48278 if (PyErr_Occurred()) SWIG_fail;
48279 }
48280 resultobj = SWIG_From_int(static_cast< int >(result));
48281 return resultobj;
48282 fail:
48283 return NULL;
48284 }
48285
48286
48287 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48288 PyObject *resultobj = 0;
48289 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48290 int result;
48291 void *argp1 = 0 ;
48292 int res1 = 0 ;
48293 PyObject *swig_obj[1] ;
48294
48295 if (!args) SWIG_fail;
48296 swig_obj[0] = args;
48297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48298 if (!SWIG_IsOK(res1)) {
48299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48300 }
48301 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48302 {
48303 PyThreadState* __tstate = wxPyBeginAllowThreads();
48304 result = (int)(arg1)->GetRows();
48305 wxPyEndAllowThreads(__tstate);
48306 if (PyErr_Occurred()) SWIG_fail;
48307 }
48308 resultobj = SWIG_From_int(static_cast< int >(result));
48309 return resultobj;
48310 fail:
48311 return NULL;
48312 }
48313
48314
48315 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48316 PyObject *resultobj = 0;
48317 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48318 int result;
48319 void *argp1 = 0 ;
48320 int res1 = 0 ;
48321 PyObject *swig_obj[1] ;
48322
48323 if (!args) SWIG_fail;
48324 swig_obj[0] = args;
48325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48326 if (!SWIG_IsOK(res1)) {
48327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48328 }
48329 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48330 {
48331 PyThreadState* __tstate = wxPyBeginAllowThreads();
48332 result = (int)(arg1)->GetVGap();
48333 wxPyEndAllowThreads(__tstate);
48334 if (PyErr_Occurred()) SWIG_fail;
48335 }
48336 resultobj = SWIG_From_int(static_cast< int >(result));
48337 return resultobj;
48338 fail:
48339 return NULL;
48340 }
48341
48342
48343 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48344 PyObject *resultobj = 0;
48345 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48346 int result;
48347 void *argp1 = 0 ;
48348 int res1 = 0 ;
48349 PyObject *swig_obj[1] ;
48350
48351 if (!args) SWIG_fail;
48352 swig_obj[0] = args;
48353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48354 if (!SWIG_IsOK(res1)) {
48355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48356 }
48357 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48358 {
48359 PyThreadState* __tstate = wxPyBeginAllowThreads();
48360 result = (int)(arg1)->GetHGap();
48361 wxPyEndAllowThreads(__tstate);
48362 if (PyErr_Occurred()) SWIG_fail;
48363 }
48364 resultobj = SWIG_From_int(static_cast< int >(result));
48365 return resultobj;
48366 fail:
48367 return NULL;
48368 }
48369
48370
48371 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48372 PyObject *obj;
48373 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48374 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48375 return SWIG_Py_Void();
48376 }
48377
48378 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48379 return SWIG_Python_InitShadowInstance(args);
48380 }
48381
48382 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48383 PyObject *resultobj = 0;
48384 int arg1 = (int) 1 ;
48385 int arg2 = (int) 0 ;
48386 int arg3 = (int) 0 ;
48387 int arg4 = (int) 0 ;
48388 wxFlexGridSizer *result = 0 ;
48389 int val1 ;
48390 int ecode1 = 0 ;
48391 int val2 ;
48392 int ecode2 = 0 ;
48393 int val3 ;
48394 int ecode3 = 0 ;
48395 int val4 ;
48396 int ecode4 = 0 ;
48397 PyObject * obj0 = 0 ;
48398 PyObject * obj1 = 0 ;
48399 PyObject * obj2 = 0 ;
48400 PyObject * obj3 = 0 ;
48401 char * kwnames[] = {
48402 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48403 };
48404
48405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48406 if (obj0) {
48407 ecode1 = SWIG_AsVal_int(obj0, &val1);
48408 if (!SWIG_IsOK(ecode1)) {
48409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48410 }
48411 arg1 = static_cast< int >(val1);
48412 }
48413 if (obj1) {
48414 ecode2 = SWIG_AsVal_int(obj1, &val2);
48415 if (!SWIG_IsOK(ecode2)) {
48416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48417 }
48418 arg2 = static_cast< int >(val2);
48419 }
48420 if (obj2) {
48421 ecode3 = SWIG_AsVal_int(obj2, &val3);
48422 if (!SWIG_IsOK(ecode3)) {
48423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48424 }
48425 arg3 = static_cast< int >(val3);
48426 }
48427 if (obj3) {
48428 ecode4 = SWIG_AsVal_int(obj3, &val4);
48429 if (!SWIG_IsOK(ecode4)) {
48430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48431 }
48432 arg4 = static_cast< int >(val4);
48433 }
48434 {
48435 PyThreadState* __tstate = wxPyBeginAllowThreads();
48436 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48437 wxPyEndAllowThreads(__tstate);
48438 if (PyErr_Occurred()) SWIG_fail;
48439 }
48440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48441 return resultobj;
48442 fail:
48443 return NULL;
48444 }
48445
48446
48447 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48448 PyObject *resultobj = 0;
48449 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48450 size_t arg2 ;
48451 int arg3 = (int) 0 ;
48452 void *argp1 = 0 ;
48453 int res1 = 0 ;
48454 size_t val2 ;
48455 int ecode2 = 0 ;
48456 int val3 ;
48457 int ecode3 = 0 ;
48458 PyObject * obj0 = 0 ;
48459 PyObject * obj1 = 0 ;
48460 PyObject * obj2 = 0 ;
48461 char * kwnames[] = {
48462 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48463 };
48464
48465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48467 if (!SWIG_IsOK(res1)) {
48468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48469 }
48470 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48471 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48472 if (!SWIG_IsOK(ecode2)) {
48473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48474 }
48475 arg2 = static_cast< size_t >(val2);
48476 if (obj2) {
48477 ecode3 = SWIG_AsVal_int(obj2, &val3);
48478 if (!SWIG_IsOK(ecode3)) {
48479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48480 }
48481 arg3 = static_cast< int >(val3);
48482 }
48483 {
48484 PyThreadState* __tstate = wxPyBeginAllowThreads();
48485 (arg1)->AddGrowableRow(arg2,arg3);
48486 wxPyEndAllowThreads(__tstate);
48487 if (PyErr_Occurred()) SWIG_fail;
48488 }
48489 resultobj = SWIG_Py_Void();
48490 return resultobj;
48491 fail:
48492 return NULL;
48493 }
48494
48495
48496 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48497 PyObject *resultobj = 0;
48498 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48499 size_t arg2 ;
48500 void *argp1 = 0 ;
48501 int res1 = 0 ;
48502 size_t val2 ;
48503 int ecode2 = 0 ;
48504 PyObject * obj0 = 0 ;
48505 PyObject * obj1 = 0 ;
48506 char * kwnames[] = {
48507 (char *) "self",(char *) "idx", NULL
48508 };
48509
48510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48512 if (!SWIG_IsOK(res1)) {
48513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48514 }
48515 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48516 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48517 if (!SWIG_IsOK(ecode2)) {
48518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48519 }
48520 arg2 = static_cast< size_t >(val2);
48521 {
48522 PyThreadState* __tstate = wxPyBeginAllowThreads();
48523 (arg1)->RemoveGrowableRow(arg2);
48524 wxPyEndAllowThreads(__tstate);
48525 if (PyErr_Occurred()) SWIG_fail;
48526 }
48527 resultobj = SWIG_Py_Void();
48528 return resultobj;
48529 fail:
48530 return NULL;
48531 }
48532
48533
48534 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48535 PyObject *resultobj = 0;
48536 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48537 size_t arg2 ;
48538 int arg3 = (int) 0 ;
48539 void *argp1 = 0 ;
48540 int res1 = 0 ;
48541 size_t val2 ;
48542 int ecode2 = 0 ;
48543 int val3 ;
48544 int ecode3 = 0 ;
48545 PyObject * obj0 = 0 ;
48546 PyObject * obj1 = 0 ;
48547 PyObject * obj2 = 0 ;
48548 char * kwnames[] = {
48549 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48550 };
48551
48552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48554 if (!SWIG_IsOK(res1)) {
48555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48556 }
48557 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48558 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48559 if (!SWIG_IsOK(ecode2)) {
48560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48561 }
48562 arg2 = static_cast< size_t >(val2);
48563 if (obj2) {
48564 ecode3 = SWIG_AsVal_int(obj2, &val3);
48565 if (!SWIG_IsOK(ecode3)) {
48566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48567 }
48568 arg3 = static_cast< int >(val3);
48569 }
48570 {
48571 PyThreadState* __tstate = wxPyBeginAllowThreads();
48572 (arg1)->AddGrowableCol(arg2,arg3);
48573 wxPyEndAllowThreads(__tstate);
48574 if (PyErr_Occurred()) SWIG_fail;
48575 }
48576 resultobj = SWIG_Py_Void();
48577 return resultobj;
48578 fail:
48579 return NULL;
48580 }
48581
48582
48583 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48584 PyObject *resultobj = 0;
48585 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48586 size_t arg2 ;
48587 void *argp1 = 0 ;
48588 int res1 = 0 ;
48589 size_t val2 ;
48590 int ecode2 = 0 ;
48591 PyObject * obj0 = 0 ;
48592 PyObject * obj1 = 0 ;
48593 char * kwnames[] = {
48594 (char *) "self",(char *) "idx", NULL
48595 };
48596
48597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48599 if (!SWIG_IsOK(res1)) {
48600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48601 }
48602 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48603 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48604 if (!SWIG_IsOK(ecode2)) {
48605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48606 }
48607 arg2 = static_cast< size_t >(val2);
48608 {
48609 PyThreadState* __tstate = wxPyBeginAllowThreads();
48610 (arg1)->RemoveGrowableCol(arg2);
48611 wxPyEndAllowThreads(__tstate);
48612 if (PyErr_Occurred()) SWIG_fail;
48613 }
48614 resultobj = SWIG_Py_Void();
48615 return resultobj;
48616 fail:
48617 return NULL;
48618 }
48619
48620
48621 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48622 PyObject *resultobj = 0;
48623 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48624 int arg2 ;
48625 void *argp1 = 0 ;
48626 int res1 = 0 ;
48627 int val2 ;
48628 int ecode2 = 0 ;
48629 PyObject * obj0 = 0 ;
48630 PyObject * obj1 = 0 ;
48631 char * kwnames[] = {
48632 (char *) "self",(char *) "direction", NULL
48633 };
48634
48635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48637 if (!SWIG_IsOK(res1)) {
48638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48639 }
48640 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48641 ecode2 = SWIG_AsVal_int(obj1, &val2);
48642 if (!SWIG_IsOK(ecode2)) {
48643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48644 }
48645 arg2 = static_cast< int >(val2);
48646 {
48647 PyThreadState* __tstate = wxPyBeginAllowThreads();
48648 (arg1)->SetFlexibleDirection(arg2);
48649 wxPyEndAllowThreads(__tstate);
48650 if (PyErr_Occurred()) SWIG_fail;
48651 }
48652 resultobj = SWIG_Py_Void();
48653 return resultobj;
48654 fail:
48655 return NULL;
48656 }
48657
48658
48659 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48660 PyObject *resultobj = 0;
48661 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48662 int result;
48663 void *argp1 = 0 ;
48664 int res1 = 0 ;
48665 PyObject *swig_obj[1] ;
48666
48667 if (!args) SWIG_fail;
48668 swig_obj[0] = args;
48669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48672 }
48673 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48674 {
48675 PyThreadState* __tstate = wxPyBeginAllowThreads();
48676 result = (int)(arg1)->GetFlexibleDirection();
48677 wxPyEndAllowThreads(__tstate);
48678 if (PyErr_Occurred()) SWIG_fail;
48679 }
48680 resultobj = SWIG_From_int(static_cast< int >(result));
48681 return resultobj;
48682 fail:
48683 return NULL;
48684 }
48685
48686
48687 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48688 PyObject *resultobj = 0;
48689 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48690 wxFlexSizerGrowMode arg2 ;
48691 void *argp1 = 0 ;
48692 int res1 = 0 ;
48693 int val2 ;
48694 int ecode2 = 0 ;
48695 PyObject * obj0 = 0 ;
48696 PyObject * obj1 = 0 ;
48697 char * kwnames[] = {
48698 (char *) "self",(char *) "mode", NULL
48699 };
48700
48701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48703 if (!SWIG_IsOK(res1)) {
48704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48705 }
48706 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48707 ecode2 = SWIG_AsVal_int(obj1, &val2);
48708 if (!SWIG_IsOK(ecode2)) {
48709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48710 }
48711 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48712 {
48713 PyThreadState* __tstate = wxPyBeginAllowThreads();
48714 (arg1)->SetNonFlexibleGrowMode(arg2);
48715 wxPyEndAllowThreads(__tstate);
48716 if (PyErr_Occurred()) SWIG_fail;
48717 }
48718 resultobj = SWIG_Py_Void();
48719 return resultobj;
48720 fail:
48721 return NULL;
48722 }
48723
48724
48725 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48726 PyObject *resultobj = 0;
48727 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48728 wxFlexSizerGrowMode result;
48729 void *argp1 = 0 ;
48730 int res1 = 0 ;
48731 PyObject *swig_obj[1] ;
48732
48733 if (!args) SWIG_fail;
48734 swig_obj[0] = args;
48735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48736 if (!SWIG_IsOK(res1)) {
48737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48738 }
48739 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48740 {
48741 PyThreadState* __tstate = wxPyBeginAllowThreads();
48742 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48743 wxPyEndAllowThreads(__tstate);
48744 if (PyErr_Occurred()) SWIG_fail;
48745 }
48746 resultobj = SWIG_From_int(static_cast< int >(result));
48747 return resultobj;
48748 fail:
48749 return NULL;
48750 }
48751
48752
48753 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48754 PyObject *resultobj = 0;
48755 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48756 wxArrayInt *result = 0 ;
48757 void *argp1 = 0 ;
48758 int res1 = 0 ;
48759 PyObject *swig_obj[1] ;
48760
48761 if (!args) SWIG_fail;
48762 swig_obj[0] = args;
48763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48764 if (!SWIG_IsOK(res1)) {
48765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48766 }
48767 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48768 {
48769 PyThreadState* __tstate = wxPyBeginAllowThreads();
48770 {
48771 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48772 result = (wxArrayInt *) &_result_ref;
48773 }
48774 wxPyEndAllowThreads(__tstate);
48775 if (PyErr_Occurred()) SWIG_fail;
48776 }
48777 {
48778 resultobj = PyList_New(0);
48779 size_t idx;
48780 for (idx = 0; idx < result->GetCount(); idx += 1) {
48781 PyObject* val = PyInt_FromLong( result->Item(idx) );
48782 PyList_Append(resultobj, val);
48783 Py_DECREF(val);
48784 }
48785 }
48786 return resultobj;
48787 fail:
48788 return NULL;
48789 }
48790
48791
48792 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48793 PyObject *resultobj = 0;
48794 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48795 wxArrayInt *result = 0 ;
48796 void *argp1 = 0 ;
48797 int res1 = 0 ;
48798 PyObject *swig_obj[1] ;
48799
48800 if (!args) SWIG_fail;
48801 swig_obj[0] = args;
48802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48803 if (!SWIG_IsOK(res1)) {
48804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48805 }
48806 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48807 {
48808 PyThreadState* __tstate = wxPyBeginAllowThreads();
48809 {
48810 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48811 result = (wxArrayInt *) &_result_ref;
48812 }
48813 wxPyEndAllowThreads(__tstate);
48814 if (PyErr_Occurred()) SWIG_fail;
48815 }
48816 {
48817 resultobj = PyList_New(0);
48818 size_t idx;
48819 for (idx = 0; idx < result->GetCount(); idx += 1) {
48820 PyObject* val = PyInt_FromLong( result->Item(idx) );
48821 PyList_Append(resultobj, val);
48822 Py_DECREF(val);
48823 }
48824 }
48825 return resultobj;
48826 fail:
48827 return NULL;
48828 }
48829
48830
48831 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48832 PyObject *obj;
48833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48834 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48835 return SWIG_Py_Void();
48836 }
48837
48838 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48839 return SWIG_Python_InitShadowInstance(args);
48840 }
48841
48842 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48843 PyObject *resultobj = 0;
48844 wxStdDialogButtonSizer *result = 0 ;
48845
48846 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48847 {
48848 PyThreadState* __tstate = wxPyBeginAllowThreads();
48849 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48850 wxPyEndAllowThreads(__tstate);
48851 if (PyErr_Occurred()) SWIG_fail;
48852 }
48853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48854 return resultobj;
48855 fail:
48856 return NULL;
48857 }
48858
48859
48860 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48861 PyObject *resultobj = 0;
48862 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48863 wxButton *arg2 = (wxButton *) 0 ;
48864 void *argp1 = 0 ;
48865 int res1 = 0 ;
48866 void *argp2 = 0 ;
48867 int res2 = 0 ;
48868 PyObject * obj0 = 0 ;
48869 PyObject * obj1 = 0 ;
48870 char * kwnames[] = {
48871 (char *) "self",(char *) "button", NULL
48872 };
48873
48874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48876 if (!SWIG_IsOK(res1)) {
48877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48878 }
48879 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48881 if (!SWIG_IsOK(res2)) {
48882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48883 }
48884 arg2 = reinterpret_cast< wxButton * >(argp2);
48885 {
48886 PyThreadState* __tstate = wxPyBeginAllowThreads();
48887 (arg1)->AddButton(arg2);
48888 wxPyEndAllowThreads(__tstate);
48889 if (PyErr_Occurred()) SWIG_fail;
48890 }
48891 resultobj = SWIG_Py_Void();
48892 return resultobj;
48893 fail:
48894 return NULL;
48895 }
48896
48897
48898 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48899 PyObject *resultobj = 0;
48900 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48901 void *argp1 = 0 ;
48902 int res1 = 0 ;
48903 PyObject *swig_obj[1] ;
48904
48905 if (!args) SWIG_fail;
48906 swig_obj[0] = args;
48907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48908 if (!SWIG_IsOK(res1)) {
48909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48910 }
48911 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48912 {
48913 PyThreadState* __tstate = wxPyBeginAllowThreads();
48914 (arg1)->Realize();
48915 wxPyEndAllowThreads(__tstate);
48916 if (PyErr_Occurred()) SWIG_fail;
48917 }
48918 resultobj = SWIG_Py_Void();
48919 return resultobj;
48920 fail:
48921 return NULL;
48922 }
48923
48924
48925 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48926 PyObject *resultobj = 0;
48927 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48928 wxButton *arg2 = (wxButton *) 0 ;
48929 void *argp1 = 0 ;
48930 int res1 = 0 ;
48931 void *argp2 = 0 ;
48932 int res2 = 0 ;
48933 PyObject * obj0 = 0 ;
48934 PyObject * obj1 = 0 ;
48935 char * kwnames[] = {
48936 (char *) "self",(char *) "button", NULL
48937 };
48938
48939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48941 if (!SWIG_IsOK(res1)) {
48942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48943 }
48944 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48945 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48946 if (!SWIG_IsOK(res2)) {
48947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48948 }
48949 arg2 = reinterpret_cast< wxButton * >(argp2);
48950 {
48951 PyThreadState* __tstate = wxPyBeginAllowThreads();
48952 (arg1)->SetAffirmativeButton(arg2);
48953 wxPyEndAllowThreads(__tstate);
48954 if (PyErr_Occurred()) SWIG_fail;
48955 }
48956 resultobj = SWIG_Py_Void();
48957 return resultobj;
48958 fail:
48959 return NULL;
48960 }
48961
48962
48963 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48964 PyObject *resultobj = 0;
48965 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48966 wxButton *arg2 = (wxButton *) 0 ;
48967 void *argp1 = 0 ;
48968 int res1 = 0 ;
48969 void *argp2 = 0 ;
48970 int res2 = 0 ;
48971 PyObject * obj0 = 0 ;
48972 PyObject * obj1 = 0 ;
48973 char * kwnames[] = {
48974 (char *) "self",(char *) "button", NULL
48975 };
48976
48977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48979 if (!SWIG_IsOK(res1)) {
48980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48981 }
48982 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48984 if (!SWIG_IsOK(res2)) {
48985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48986 }
48987 arg2 = reinterpret_cast< wxButton * >(argp2);
48988 {
48989 PyThreadState* __tstate = wxPyBeginAllowThreads();
48990 (arg1)->SetNegativeButton(arg2);
48991 wxPyEndAllowThreads(__tstate);
48992 if (PyErr_Occurred()) SWIG_fail;
48993 }
48994 resultobj = SWIG_Py_Void();
48995 return resultobj;
48996 fail:
48997 return NULL;
48998 }
48999
49000
49001 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49002 PyObject *resultobj = 0;
49003 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49004 wxButton *arg2 = (wxButton *) 0 ;
49005 void *argp1 = 0 ;
49006 int res1 = 0 ;
49007 void *argp2 = 0 ;
49008 int res2 = 0 ;
49009 PyObject * obj0 = 0 ;
49010 PyObject * obj1 = 0 ;
49011 char * kwnames[] = {
49012 (char *) "self",(char *) "button", NULL
49013 };
49014
49015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49017 if (!SWIG_IsOK(res1)) {
49018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49019 }
49020 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49022 if (!SWIG_IsOK(res2)) {
49023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49024 }
49025 arg2 = reinterpret_cast< wxButton * >(argp2);
49026 {
49027 PyThreadState* __tstate = wxPyBeginAllowThreads();
49028 (arg1)->SetCancelButton(arg2);
49029 wxPyEndAllowThreads(__tstate);
49030 if (PyErr_Occurred()) SWIG_fail;
49031 }
49032 resultobj = SWIG_Py_Void();
49033 return resultobj;
49034 fail:
49035 return NULL;
49036 }
49037
49038
49039 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49040 PyObject *resultobj = 0;
49041 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49042 wxButton *result = 0 ;
49043 void *argp1 = 0 ;
49044 int res1 = 0 ;
49045 PyObject *swig_obj[1] ;
49046
49047 if (!args) SWIG_fail;
49048 swig_obj[0] = args;
49049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49050 if (!SWIG_IsOK(res1)) {
49051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49052 }
49053 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49054 {
49055 PyThreadState* __tstate = wxPyBeginAllowThreads();
49056 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49057 wxPyEndAllowThreads(__tstate);
49058 if (PyErr_Occurred()) SWIG_fail;
49059 }
49060 {
49061 resultobj = wxPyMake_wxObject(result, (bool)0);
49062 }
49063 return resultobj;
49064 fail:
49065 return NULL;
49066 }
49067
49068
49069 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49070 PyObject *resultobj = 0;
49071 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49072 wxButton *result = 0 ;
49073 void *argp1 = 0 ;
49074 int res1 = 0 ;
49075 PyObject *swig_obj[1] ;
49076
49077 if (!args) SWIG_fail;
49078 swig_obj[0] = args;
49079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49080 if (!SWIG_IsOK(res1)) {
49081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49082 }
49083 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49084 {
49085 PyThreadState* __tstate = wxPyBeginAllowThreads();
49086 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49087 wxPyEndAllowThreads(__tstate);
49088 if (PyErr_Occurred()) SWIG_fail;
49089 }
49090 {
49091 resultobj = wxPyMake_wxObject(result, (bool)0);
49092 }
49093 return resultobj;
49094 fail:
49095 return NULL;
49096 }
49097
49098
49099 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49100 PyObject *resultobj = 0;
49101 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49102 wxButton *result = 0 ;
49103 void *argp1 = 0 ;
49104 int res1 = 0 ;
49105 PyObject *swig_obj[1] ;
49106
49107 if (!args) SWIG_fail;
49108 swig_obj[0] = args;
49109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49110 if (!SWIG_IsOK(res1)) {
49111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49112 }
49113 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49114 {
49115 PyThreadState* __tstate = wxPyBeginAllowThreads();
49116 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49117 wxPyEndAllowThreads(__tstate);
49118 if (PyErr_Occurred()) SWIG_fail;
49119 }
49120 {
49121 resultobj = wxPyMake_wxObject(result, (bool)0);
49122 }
49123 return resultobj;
49124 fail:
49125 return NULL;
49126 }
49127
49128
49129 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49130 PyObject *resultobj = 0;
49131 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49132 wxButton *result = 0 ;
49133 void *argp1 = 0 ;
49134 int res1 = 0 ;
49135 PyObject *swig_obj[1] ;
49136
49137 if (!args) SWIG_fail;
49138 swig_obj[0] = args;
49139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49140 if (!SWIG_IsOK(res1)) {
49141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49142 }
49143 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49144 {
49145 PyThreadState* __tstate = wxPyBeginAllowThreads();
49146 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49147 wxPyEndAllowThreads(__tstate);
49148 if (PyErr_Occurred()) SWIG_fail;
49149 }
49150 {
49151 resultobj = wxPyMake_wxObject(result, (bool)0);
49152 }
49153 return resultobj;
49154 fail:
49155 return NULL;
49156 }
49157
49158
49159 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49160 PyObject *resultobj = 0;
49161 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49162 wxButton *result = 0 ;
49163 void *argp1 = 0 ;
49164 int res1 = 0 ;
49165 PyObject *swig_obj[1] ;
49166
49167 if (!args) SWIG_fail;
49168 swig_obj[0] = args;
49169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49170 if (!SWIG_IsOK(res1)) {
49171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49172 }
49173 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49174 {
49175 PyThreadState* __tstate = wxPyBeginAllowThreads();
49176 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49177 wxPyEndAllowThreads(__tstate);
49178 if (PyErr_Occurred()) SWIG_fail;
49179 }
49180 {
49181 resultobj = wxPyMake_wxObject(result, (bool)0);
49182 }
49183 return resultobj;
49184 fail:
49185 return NULL;
49186 }
49187
49188
49189 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49190 PyObject *obj;
49191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49192 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49193 return SWIG_Py_Void();
49194 }
49195
49196 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49197 return SWIG_Python_InitShadowInstance(args);
49198 }
49199
49200 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49201 PyObject *resultobj = 0;
49202 int arg1 = (int) 0 ;
49203 int arg2 = (int) 0 ;
49204 wxGBPosition *result = 0 ;
49205 int val1 ;
49206 int ecode1 = 0 ;
49207 int val2 ;
49208 int ecode2 = 0 ;
49209 PyObject * obj0 = 0 ;
49210 PyObject * obj1 = 0 ;
49211 char * kwnames[] = {
49212 (char *) "row",(char *) "col", NULL
49213 };
49214
49215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49216 if (obj0) {
49217 ecode1 = SWIG_AsVal_int(obj0, &val1);
49218 if (!SWIG_IsOK(ecode1)) {
49219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49220 }
49221 arg1 = static_cast< int >(val1);
49222 }
49223 if (obj1) {
49224 ecode2 = SWIG_AsVal_int(obj1, &val2);
49225 if (!SWIG_IsOK(ecode2)) {
49226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49227 }
49228 arg2 = static_cast< int >(val2);
49229 }
49230 {
49231 PyThreadState* __tstate = wxPyBeginAllowThreads();
49232 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49233 wxPyEndAllowThreads(__tstate);
49234 if (PyErr_Occurred()) SWIG_fail;
49235 }
49236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49237 return resultobj;
49238 fail:
49239 return NULL;
49240 }
49241
49242
49243 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49244 PyObject *resultobj = 0;
49245 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49246 void *argp1 = 0 ;
49247 int res1 = 0 ;
49248 PyObject *swig_obj[1] ;
49249
49250 if (!args) SWIG_fail;
49251 swig_obj[0] = args;
49252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49253 if (!SWIG_IsOK(res1)) {
49254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49255 }
49256 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49257 {
49258 PyThreadState* __tstate = wxPyBeginAllowThreads();
49259 delete arg1;
49260
49261 wxPyEndAllowThreads(__tstate);
49262 if (PyErr_Occurred()) SWIG_fail;
49263 }
49264 resultobj = SWIG_Py_Void();
49265 return resultobj;
49266 fail:
49267 return NULL;
49268 }
49269
49270
49271 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49272 PyObject *resultobj = 0;
49273 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49274 int result;
49275 void *argp1 = 0 ;
49276 int res1 = 0 ;
49277 PyObject *swig_obj[1] ;
49278
49279 if (!args) SWIG_fail;
49280 swig_obj[0] = args;
49281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49282 if (!SWIG_IsOK(res1)) {
49283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49284 }
49285 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49286 {
49287 PyThreadState* __tstate = wxPyBeginAllowThreads();
49288 result = (int)((wxGBPosition const *)arg1)->GetRow();
49289 wxPyEndAllowThreads(__tstate);
49290 if (PyErr_Occurred()) SWIG_fail;
49291 }
49292 resultobj = SWIG_From_int(static_cast< int >(result));
49293 return resultobj;
49294 fail:
49295 return NULL;
49296 }
49297
49298
49299 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49300 PyObject *resultobj = 0;
49301 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49302 int result;
49303 void *argp1 = 0 ;
49304 int res1 = 0 ;
49305 PyObject *swig_obj[1] ;
49306
49307 if (!args) SWIG_fail;
49308 swig_obj[0] = args;
49309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49310 if (!SWIG_IsOK(res1)) {
49311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49312 }
49313 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49314 {
49315 PyThreadState* __tstate = wxPyBeginAllowThreads();
49316 result = (int)((wxGBPosition const *)arg1)->GetCol();
49317 wxPyEndAllowThreads(__tstate);
49318 if (PyErr_Occurred()) SWIG_fail;
49319 }
49320 resultobj = SWIG_From_int(static_cast< int >(result));
49321 return resultobj;
49322 fail:
49323 return NULL;
49324 }
49325
49326
49327 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49328 PyObject *resultobj = 0;
49329 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49330 int arg2 ;
49331 void *argp1 = 0 ;
49332 int res1 = 0 ;
49333 int val2 ;
49334 int ecode2 = 0 ;
49335 PyObject * obj0 = 0 ;
49336 PyObject * obj1 = 0 ;
49337 char * kwnames[] = {
49338 (char *) "self",(char *) "row", NULL
49339 };
49340
49341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49343 if (!SWIG_IsOK(res1)) {
49344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49345 }
49346 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49347 ecode2 = SWIG_AsVal_int(obj1, &val2);
49348 if (!SWIG_IsOK(ecode2)) {
49349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49350 }
49351 arg2 = static_cast< int >(val2);
49352 {
49353 PyThreadState* __tstate = wxPyBeginAllowThreads();
49354 (arg1)->SetRow(arg2);
49355 wxPyEndAllowThreads(__tstate);
49356 if (PyErr_Occurred()) SWIG_fail;
49357 }
49358 resultobj = SWIG_Py_Void();
49359 return resultobj;
49360 fail:
49361 return NULL;
49362 }
49363
49364
49365 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49366 PyObject *resultobj = 0;
49367 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49368 int arg2 ;
49369 void *argp1 = 0 ;
49370 int res1 = 0 ;
49371 int val2 ;
49372 int ecode2 = 0 ;
49373 PyObject * obj0 = 0 ;
49374 PyObject * obj1 = 0 ;
49375 char * kwnames[] = {
49376 (char *) "self",(char *) "col", NULL
49377 };
49378
49379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49381 if (!SWIG_IsOK(res1)) {
49382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49383 }
49384 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49385 ecode2 = SWIG_AsVal_int(obj1, &val2);
49386 if (!SWIG_IsOK(ecode2)) {
49387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49388 }
49389 arg2 = static_cast< int >(val2);
49390 {
49391 PyThreadState* __tstate = wxPyBeginAllowThreads();
49392 (arg1)->SetCol(arg2);
49393 wxPyEndAllowThreads(__tstate);
49394 if (PyErr_Occurred()) SWIG_fail;
49395 }
49396 resultobj = SWIG_Py_Void();
49397 return resultobj;
49398 fail:
49399 return NULL;
49400 }
49401
49402
49403 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49404 PyObject *resultobj = 0;
49405 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49406 PyObject *arg2 = (PyObject *) 0 ;
49407 bool result;
49408 void *argp1 = 0 ;
49409 int res1 = 0 ;
49410 PyObject * obj0 = 0 ;
49411 PyObject * obj1 = 0 ;
49412 char * kwnames[] = {
49413 (char *) "self",(char *) "other", NULL
49414 };
49415
49416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49418 if (!SWIG_IsOK(res1)) {
49419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49420 }
49421 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49422 arg2 = obj1;
49423 {
49424 result = (bool)wxGBPosition___eq__(arg1,arg2);
49425 if (PyErr_Occurred()) SWIG_fail;
49426 }
49427 {
49428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49429 }
49430 return resultobj;
49431 fail:
49432 return NULL;
49433 }
49434
49435
49436 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49437 PyObject *resultobj = 0;
49438 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49439 PyObject *arg2 = (PyObject *) 0 ;
49440 bool result;
49441 void *argp1 = 0 ;
49442 int res1 = 0 ;
49443 PyObject * obj0 = 0 ;
49444 PyObject * obj1 = 0 ;
49445 char * kwnames[] = {
49446 (char *) "self",(char *) "other", NULL
49447 };
49448
49449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49451 if (!SWIG_IsOK(res1)) {
49452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49453 }
49454 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49455 arg2 = obj1;
49456 {
49457 result = (bool)wxGBPosition___ne__(arg1,arg2);
49458 if (PyErr_Occurred()) SWIG_fail;
49459 }
49460 {
49461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49462 }
49463 return resultobj;
49464 fail:
49465 return NULL;
49466 }
49467
49468
49469 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49470 PyObject *resultobj = 0;
49471 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49472 int arg2 = (int) 0 ;
49473 int arg3 = (int) 0 ;
49474 void *argp1 = 0 ;
49475 int res1 = 0 ;
49476 int val2 ;
49477 int ecode2 = 0 ;
49478 int val3 ;
49479 int ecode3 = 0 ;
49480 PyObject * obj0 = 0 ;
49481 PyObject * obj1 = 0 ;
49482 PyObject * obj2 = 0 ;
49483 char * kwnames[] = {
49484 (char *) "self",(char *) "row",(char *) "col", NULL
49485 };
49486
49487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49489 if (!SWIG_IsOK(res1)) {
49490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49491 }
49492 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49493 if (obj1) {
49494 ecode2 = SWIG_AsVal_int(obj1, &val2);
49495 if (!SWIG_IsOK(ecode2)) {
49496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49497 }
49498 arg2 = static_cast< int >(val2);
49499 }
49500 if (obj2) {
49501 ecode3 = SWIG_AsVal_int(obj2, &val3);
49502 if (!SWIG_IsOK(ecode3)) {
49503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49504 }
49505 arg3 = static_cast< int >(val3);
49506 }
49507 {
49508 PyThreadState* __tstate = wxPyBeginAllowThreads();
49509 wxGBPosition_Set(arg1,arg2,arg3);
49510 wxPyEndAllowThreads(__tstate);
49511 if (PyErr_Occurred()) SWIG_fail;
49512 }
49513 resultobj = SWIG_Py_Void();
49514 return resultobj;
49515 fail:
49516 return NULL;
49517 }
49518
49519
49520 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49521 PyObject *resultobj = 0;
49522 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49523 PyObject *result = 0 ;
49524 void *argp1 = 0 ;
49525 int res1 = 0 ;
49526 PyObject *swig_obj[1] ;
49527
49528 if (!args) SWIG_fail;
49529 swig_obj[0] = args;
49530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49531 if (!SWIG_IsOK(res1)) {
49532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49533 }
49534 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49535 {
49536 PyThreadState* __tstate = wxPyBeginAllowThreads();
49537 result = (PyObject *)wxGBPosition_Get(arg1);
49538 wxPyEndAllowThreads(__tstate);
49539 if (PyErr_Occurred()) SWIG_fail;
49540 }
49541 resultobj = result;
49542 return resultobj;
49543 fail:
49544 return NULL;
49545 }
49546
49547
49548 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49549 PyObject *obj;
49550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49551 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49552 return SWIG_Py_Void();
49553 }
49554
49555 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49556 return SWIG_Python_InitShadowInstance(args);
49557 }
49558
49559 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49560 PyObject *resultobj = 0;
49561 int arg1 = (int) 1 ;
49562 int arg2 = (int) 1 ;
49563 wxGBSpan *result = 0 ;
49564 int val1 ;
49565 int ecode1 = 0 ;
49566 int val2 ;
49567 int ecode2 = 0 ;
49568 PyObject * obj0 = 0 ;
49569 PyObject * obj1 = 0 ;
49570 char * kwnames[] = {
49571 (char *) "rowspan",(char *) "colspan", NULL
49572 };
49573
49574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49575 if (obj0) {
49576 ecode1 = SWIG_AsVal_int(obj0, &val1);
49577 if (!SWIG_IsOK(ecode1)) {
49578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49579 }
49580 arg1 = static_cast< int >(val1);
49581 }
49582 if (obj1) {
49583 ecode2 = SWIG_AsVal_int(obj1, &val2);
49584 if (!SWIG_IsOK(ecode2)) {
49585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49586 }
49587 arg2 = static_cast< int >(val2);
49588 }
49589 {
49590 PyThreadState* __tstate = wxPyBeginAllowThreads();
49591 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49592 wxPyEndAllowThreads(__tstate);
49593 if (PyErr_Occurred()) SWIG_fail;
49594 }
49595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49596 return resultobj;
49597 fail:
49598 return NULL;
49599 }
49600
49601
49602 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49603 PyObject *resultobj = 0;
49604 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49605 void *argp1 = 0 ;
49606 int res1 = 0 ;
49607 PyObject *swig_obj[1] ;
49608
49609 if (!args) SWIG_fail;
49610 swig_obj[0] = args;
49611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49612 if (!SWIG_IsOK(res1)) {
49613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49614 }
49615 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49616 {
49617 PyThreadState* __tstate = wxPyBeginAllowThreads();
49618 delete arg1;
49619
49620 wxPyEndAllowThreads(__tstate);
49621 if (PyErr_Occurred()) SWIG_fail;
49622 }
49623 resultobj = SWIG_Py_Void();
49624 return resultobj;
49625 fail:
49626 return NULL;
49627 }
49628
49629
49630 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49631 PyObject *resultobj = 0;
49632 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49633 int result;
49634 void *argp1 = 0 ;
49635 int res1 = 0 ;
49636 PyObject *swig_obj[1] ;
49637
49638 if (!args) SWIG_fail;
49639 swig_obj[0] = args;
49640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49641 if (!SWIG_IsOK(res1)) {
49642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49643 }
49644 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49645 {
49646 PyThreadState* __tstate = wxPyBeginAllowThreads();
49647 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49648 wxPyEndAllowThreads(__tstate);
49649 if (PyErr_Occurred()) SWIG_fail;
49650 }
49651 resultobj = SWIG_From_int(static_cast< int >(result));
49652 return resultobj;
49653 fail:
49654 return NULL;
49655 }
49656
49657
49658 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49659 PyObject *resultobj = 0;
49660 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49661 int result;
49662 void *argp1 = 0 ;
49663 int res1 = 0 ;
49664 PyObject *swig_obj[1] ;
49665
49666 if (!args) SWIG_fail;
49667 swig_obj[0] = args;
49668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49669 if (!SWIG_IsOK(res1)) {
49670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49671 }
49672 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49673 {
49674 PyThreadState* __tstate = wxPyBeginAllowThreads();
49675 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49676 wxPyEndAllowThreads(__tstate);
49677 if (PyErr_Occurred()) SWIG_fail;
49678 }
49679 resultobj = SWIG_From_int(static_cast< int >(result));
49680 return resultobj;
49681 fail:
49682 return NULL;
49683 }
49684
49685
49686 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49687 PyObject *resultobj = 0;
49688 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49689 int arg2 ;
49690 void *argp1 = 0 ;
49691 int res1 = 0 ;
49692 int val2 ;
49693 int ecode2 = 0 ;
49694 PyObject * obj0 = 0 ;
49695 PyObject * obj1 = 0 ;
49696 char * kwnames[] = {
49697 (char *) "self",(char *) "rowspan", NULL
49698 };
49699
49700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49702 if (!SWIG_IsOK(res1)) {
49703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49704 }
49705 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49706 ecode2 = SWIG_AsVal_int(obj1, &val2);
49707 if (!SWIG_IsOK(ecode2)) {
49708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49709 }
49710 arg2 = static_cast< int >(val2);
49711 {
49712 PyThreadState* __tstate = wxPyBeginAllowThreads();
49713 (arg1)->SetRowspan(arg2);
49714 wxPyEndAllowThreads(__tstate);
49715 if (PyErr_Occurred()) SWIG_fail;
49716 }
49717 resultobj = SWIG_Py_Void();
49718 return resultobj;
49719 fail:
49720 return NULL;
49721 }
49722
49723
49724 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49725 PyObject *resultobj = 0;
49726 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49727 int arg2 ;
49728 void *argp1 = 0 ;
49729 int res1 = 0 ;
49730 int val2 ;
49731 int ecode2 = 0 ;
49732 PyObject * obj0 = 0 ;
49733 PyObject * obj1 = 0 ;
49734 char * kwnames[] = {
49735 (char *) "self",(char *) "colspan", NULL
49736 };
49737
49738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49740 if (!SWIG_IsOK(res1)) {
49741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49742 }
49743 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49744 ecode2 = SWIG_AsVal_int(obj1, &val2);
49745 if (!SWIG_IsOK(ecode2)) {
49746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49747 }
49748 arg2 = static_cast< int >(val2);
49749 {
49750 PyThreadState* __tstate = wxPyBeginAllowThreads();
49751 (arg1)->SetColspan(arg2);
49752 wxPyEndAllowThreads(__tstate);
49753 if (PyErr_Occurred()) SWIG_fail;
49754 }
49755 resultobj = SWIG_Py_Void();
49756 return resultobj;
49757 fail:
49758 return NULL;
49759 }
49760
49761
49762 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49763 PyObject *resultobj = 0;
49764 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49765 PyObject *arg2 = (PyObject *) 0 ;
49766 bool result;
49767 void *argp1 = 0 ;
49768 int res1 = 0 ;
49769 PyObject * obj0 = 0 ;
49770 PyObject * obj1 = 0 ;
49771 char * kwnames[] = {
49772 (char *) "self",(char *) "other", NULL
49773 };
49774
49775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49777 if (!SWIG_IsOK(res1)) {
49778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49779 }
49780 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49781 arg2 = obj1;
49782 {
49783 result = (bool)wxGBSpan___eq__(arg1,arg2);
49784 if (PyErr_Occurred()) SWIG_fail;
49785 }
49786 {
49787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49788 }
49789 return resultobj;
49790 fail:
49791 return NULL;
49792 }
49793
49794
49795 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49796 PyObject *resultobj = 0;
49797 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49798 PyObject *arg2 = (PyObject *) 0 ;
49799 bool result;
49800 void *argp1 = 0 ;
49801 int res1 = 0 ;
49802 PyObject * obj0 = 0 ;
49803 PyObject * obj1 = 0 ;
49804 char * kwnames[] = {
49805 (char *) "self",(char *) "other", NULL
49806 };
49807
49808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49810 if (!SWIG_IsOK(res1)) {
49811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49812 }
49813 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49814 arg2 = obj1;
49815 {
49816 result = (bool)wxGBSpan___ne__(arg1,arg2);
49817 if (PyErr_Occurred()) SWIG_fail;
49818 }
49819 {
49820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49821 }
49822 return resultobj;
49823 fail:
49824 return NULL;
49825 }
49826
49827
49828 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49829 PyObject *resultobj = 0;
49830 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49831 int arg2 = (int) 1 ;
49832 int arg3 = (int) 1 ;
49833 void *argp1 = 0 ;
49834 int res1 = 0 ;
49835 int val2 ;
49836 int ecode2 = 0 ;
49837 int val3 ;
49838 int ecode3 = 0 ;
49839 PyObject * obj0 = 0 ;
49840 PyObject * obj1 = 0 ;
49841 PyObject * obj2 = 0 ;
49842 char * kwnames[] = {
49843 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49844 };
49845
49846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49848 if (!SWIG_IsOK(res1)) {
49849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49850 }
49851 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49852 if (obj1) {
49853 ecode2 = SWIG_AsVal_int(obj1, &val2);
49854 if (!SWIG_IsOK(ecode2)) {
49855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49856 }
49857 arg2 = static_cast< int >(val2);
49858 }
49859 if (obj2) {
49860 ecode3 = SWIG_AsVal_int(obj2, &val3);
49861 if (!SWIG_IsOK(ecode3)) {
49862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49863 }
49864 arg3 = static_cast< int >(val3);
49865 }
49866 {
49867 PyThreadState* __tstate = wxPyBeginAllowThreads();
49868 wxGBSpan_Set(arg1,arg2,arg3);
49869 wxPyEndAllowThreads(__tstate);
49870 if (PyErr_Occurred()) SWIG_fail;
49871 }
49872 resultobj = SWIG_Py_Void();
49873 return resultobj;
49874 fail:
49875 return NULL;
49876 }
49877
49878
49879 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49880 PyObject *resultobj = 0;
49881 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49882 PyObject *result = 0 ;
49883 void *argp1 = 0 ;
49884 int res1 = 0 ;
49885 PyObject *swig_obj[1] ;
49886
49887 if (!args) SWIG_fail;
49888 swig_obj[0] = args;
49889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49890 if (!SWIG_IsOK(res1)) {
49891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49892 }
49893 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49894 {
49895 PyThreadState* __tstate = wxPyBeginAllowThreads();
49896 result = (PyObject *)wxGBSpan_Get(arg1);
49897 wxPyEndAllowThreads(__tstate);
49898 if (PyErr_Occurred()) SWIG_fail;
49899 }
49900 resultobj = result;
49901 return resultobj;
49902 fail:
49903 return NULL;
49904 }
49905
49906
49907 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49908 PyObject *obj;
49909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49910 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49911 return SWIG_Py_Void();
49912 }
49913
49914 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49915 return SWIG_Python_InitShadowInstance(args);
49916 }
49917
49918 SWIGINTERN int DefaultSpan_set(PyObject *) {
49919 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49920 return 1;
49921 }
49922
49923
49924 SWIGINTERN PyObject *DefaultSpan_get(void) {
49925 PyObject *pyobj = 0;
49926
49927 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49928 return pyobj;
49929 }
49930
49931
49932 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49933 PyObject *resultobj = 0;
49934 wxGBSizerItem *result = 0 ;
49935
49936 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49937 {
49938 PyThreadState* __tstate = wxPyBeginAllowThreads();
49939 result = (wxGBSizerItem *)new wxGBSizerItem();
49940 wxPyEndAllowThreads(__tstate);
49941 if (PyErr_Occurred()) SWIG_fail;
49942 }
49943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49944 return resultobj;
49945 fail:
49946 return NULL;
49947 }
49948
49949
49950 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49951 PyObject *resultobj = 0;
49952 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49953 void *argp1 = 0 ;
49954 int res1 = 0 ;
49955 PyObject *swig_obj[1] ;
49956
49957 if (!args) SWIG_fail;
49958 swig_obj[0] = args;
49959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49960 if (!SWIG_IsOK(res1)) {
49961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49962 }
49963 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49964 {
49965 PyThreadState* __tstate = wxPyBeginAllowThreads();
49966 delete arg1;
49967
49968 wxPyEndAllowThreads(__tstate);
49969 if (PyErr_Occurred()) SWIG_fail;
49970 }
49971 resultobj = SWIG_Py_Void();
49972 return resultobj;
49973 fail:
49974 return NULL;
49975 }
49976
49977
49978 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49979 PyObject *resultobj = 0;
49980 wxWindow *arg1 = (wxWindow *) 0 ;
49981 wxGBPosition *arg2 = 0 ;
49982 wxGBSpan *arg3 = 0 ;
49983 int arg4 ;
49984 int arg5 ;
49985 PyObject *arg6 = (PyObject *) NULL ;
49986 wxGBSizerItem *result = 0 ;
49987 void *argp1 = 0 ;
49988 int res1 = 0 ;
49989 wxGBPosition temp2 ;
49990 wxGBSpan temp3 ;
49991 int val4 ;
49992 int ecode4 = 0 ;
49993 int val5 ;
49994 int ecode5 = 0 ;
49995 PyObject * obj0 = 0 ;
49996 PyObject * obj1 = 0 ;
49997 PyObject * obj2 = 0 ;
49998 PyObject * obj3 = 0 ;
49999 PyObject * obj4 = 0 ;
50000 PyObject * obj5 = 0 ;
50001 char * kwnames[] = {
50002 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50003 };
50004
50005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50007 if (!SWIG_IsOK(res1)) {
50008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50009 }
50010 arg1 = reinterpret_cast< wxWindow * >(argp1);
50011 {
50012 arg2 = &temp2;
50013 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50014 }
50015 {
50016 arg3 = &temp3;
50017 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50018 }
50019 ecode4 = SWIG_AsVal_int(obj3, &val4);
50020 if (!SWIG_IsOK(ecode4)) {
50021 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50022 }
50023 arg4 = static_cast< int >(val4);
50024 ecode5 = SWIG_AsVal_int(obj4, &val5);
50025 if (!SWIG_IsOK(ecode5)) {
50026 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50027 }
50028 arg5 = static_cast< int >(val5);
50029 if (obj5) {
50030 arg6 = obj5;
50031 }
50032 {
50033 PyThreadState* __tstate = wxPyBeginAllowThreads();
50034 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50035 wxPyEndAllowThreads(__tstate);
50036 if (PyErr_Occurred()) SWIG_fail;
50037 }
50038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50039 return resultobj;
50040 fail:
50041 return NULL;
50042 }
50043
50044
50045 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50046 PyObject *resultobj = 0;
50047 wxSizer *arg1 = (wxSizer *) 0 ;
50048 wxGBPosition *arg2 = 0 ;
50049 wxGBSpan *arg3 = 0 ;
50050 int arg4 ;
50051 int arg5 ;
50052 PyObject *arg6 = (PyObject *) NULL ;
50053 wxGBSizerItem *result = 0 ;
50054 int res1 = 0 ;
50055 wxGBPosition temp2 ;
50056 wxGBSpan temp3 ;
50057 int val4 ;
50058 int ecode4 = 0 ;
50059 int val5 ;
50060 int ecode5 = 0 ;
50061 PyObject * obj0 = 0 ;
50062 PyObject * obj1 = 0 ;
50063 PyObject * obj2 = 0 ;
50064 PyObject * obj3 = 0 ;
50065 PyObject * obj4 = 0 ;
50066 PyObject * obj5 = 0 ;
50067 char * kwnames[] = {
50068 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50069 };
50070
50071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50072 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50073 if (!SWIG_IsOK(res1)) {
50074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50075 }
50076 {
50077 arg2 = &temp2;
50078 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50079 }
50080 {
50081 arg3 = &temp3;
50082 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50083 }
50084 ecode4 = SWIG_AsVal_int(obj3, &val4);
50085 if (!SWIG_IsOK(ecode4)) {
50086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50087 }
50088 arg4 = static_cast< int >(val4);
50089 ecode5 = SWIG_AsVal_int(obj4, &val5);
50090 if (!SWIG_IsOK(ecode5)) {
50091 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50092 }
50093 arg5 = static_cast< int >(val5);
50094 if (obj5) {
50095 arg6 = obj5;
50096 }
50097 {
50098 PyThreadState* __tstate = wxPyBeginAllowThreads();
50099 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50100 wxPyEndAllowThreads(__tstate);
50101 if (PyErr_Occurred()) SWIG_fail;
50102 }
50103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50104 return resultobj;
50105 fail:
50106 return NULL;
50107 }
50108
50109
50110 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50111 PyObject *resultobj = 0;
50112 int arg1 ;
50113 int arg2 ;
50114 wxGBPosition *arg3 = 0 ;
50115 wxGBSpan *arg4 = 0 ;
50116 int arg5 ;
50117 int arg6 ;
50118 PyObject *arg7 = (PyObject *) NULL ;
50119 wxGBSizerItem *result = 0 ;
50120 int val1 ;
50121 int ecode1 = 0 ;
50122 int val2 ;
50123 int ecode2 = 0 ;
50124 wxGBPosition temp3 ;
50125 wxGBSpan temp4 ;
50126 int val5 ;
50127 int ecode5 = 0 ;
50128 int val6 ;
50129 int ecode6 = 0 ;
50130 PyObject * obj0 = 0 ;
50131 PyObject * obj1 = 0 ;
50132 PyObject * obj2 = 0 ;
50133 PyObject * obj3 = 0 ;
50134 PyObject * obj4 = 0 ;
50135 PyObject * obj5 = 0 ;
50136 PyObject * obj6 = 0 ;
50137 char * kwnames[] = {
50138 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50139 };
50140
50141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50142 ecode1 = SWIG_AsVal_int(obj0, &val1);
50143 if (!SWIG_IsOK(ecode1)) {
50144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50145 }
50146 arg1 = static_cast< int >(val1);
50147 ecode2 = SWIG_AsVal_int(obj1, &val2);
50148 if (!SWIG_IsOK(ecode2)) {
50149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50150 }
50151 arg2 = static_cast< int >(val2);
50152 {
50153 arg3 = &temp3;
50154 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50155 }
50156 {
50157 arg4 = &temp4;
50158 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50159 }
50160 ecode5 = SWIG_AsVal_int(obj4, &val5);
50161 if (!SWIG_IsOK(ecode5)) {
50162 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50163 }
50164 arg5 = static_cast< int >(val5);
50165 ecode6 = SWIG_AsVal_int(obj5, &val6);
50166 if (!SWIG_IsOK(ecode6)) {
50167 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50168 }
50169 arg6 = static_cast< int >(val6);
50170 if (obj6) {
50171 arg7 = obj6;
50172 }
50173 {
50174 PyThreadState* __tstate = wxPyBeginAllowThreads();
50175 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50176 wxPyEndAllowThreads(__tstate);
50177 if (PyErr_Occurred()) SWIG_fail;
50178 }
50179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50180 return resultobj;
50181 fail:
50182 return NULL;
50183 }
50184
50185
50186 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50187 PyObject *resultobj = 0;
50188 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50189 wxGBPosition result;
50190 void *argp1 = 0 ;
50191 int res1 = 0 ;
50192 PyObject *swig_obj[1] ;
50193
50194 if (!args) SWIG_fail;
50195 swig_obj[0] = args;
50196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50197 if (!SWIG_IsOK(res1)) {
50198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50199 }
50200 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50201 {
50202 PyThreadState* __tstate = wxPyBeginAllowThreads();
50203 result = ((wxGBSizerItem const *)arg1)->GetPos();
50204 wxPyEndAllowThreads(__tstate);
50205 if (PyErr_Occurred()) SWIG_fail;
50206 }
50207 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50208 return resultobj;
50209 fail:
50210 return NULL;
50211 }
50212
50213
50214 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50215 PyObject *resultobj = 0;
50216 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50217 wxGBSpan result;
50218 void *argp1 = 0 ;
50219 int res1 = 0 ;
50220 PyObject *swig_obj[1] ;
50221
50222 if (!args) SWIG_fail;
50223 swig_obj[0] = args;
50224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50225 if (!SWIG_IsOK(res1)) {
50226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50227 }
50228 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50229 {
50230 PyThreadState* __tstate = wxPyBeginAllowThreads();
50231 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50232 wxPyEndAllowThreads(__tstate);
50233 if (PyErr_Occurred()) SWIG_fail;
50234 }
50235 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50236 return resultobj;
50237 fail:
50238 return NULL;
50239 }
50240
50241
50242 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50243 PyObject *resultobj = 0;
50244 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50245 wxGBPosition *arg2 = 0 ;
50246 bool result;
50247 void *argp1 = 0 ;
50248 int res1 = 0 ;
50249 wxGBPosition temp2 ;
50250 PyObject * obj0 = 0 ;
50251 PyObject * obj1 = 0 ;
50252 char * kwnames[] = {
50253 (char *) "self",(char *) "pos", NULL
50254 };
50255
50256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50258 if (!SWIG_IsOK(res1)) {
50259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50260 }
50261 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50262 {
50263 arg2 = &temp2;
50264 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50265 }
50266 {
50267 PyThreadState* __tstate = wxPyBeginAllowThreads();
50268 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50269 wxPyEndAllowThreads(__tstate);
50270 if (PyErr_Occurred()) SWIG_fail;
50271 }
50272 {
50273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50274 }
50275 return resultobj;
50276 fail:
50277 return NULL;
50278 }
50279
50280
50281 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50282 PyObject *resultobj = 0;
50283 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50284 wxGBSpan *arg2 = 0 ;
50285 bool result;
50286 void *argp1 = 0 ;
50287 int res1 = 0 ;
50288 wxGBSpan temp2 ;
50289 PyObject * obj0 = 0 ;
50290 PyObject * obj1 = 0 ;
50291 char * kwnames[] = {
50292 (char *) "self",(char *) "span", NULL
50293 };
50294
50295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50297 if (!SWIG_IsOK(res1)) {
50298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50299 }
50300 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50301 {
50302 arg2 = &temp2;
50303 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50304 }
50305 {
50306 PyThreadState* __tstate = wxPyBeginAllowThreads();
50307 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50308 wxPyEndAllowThreads(__tstate);
50309 if (PyErr_Occurred()) SWIG_fail;
50310 }
50311 {
50312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50313 }
50314 return resultobj;
50315 fail:
50316 return NULL;
50317 }
50318
50319
50320 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50321 PyObject *resultobj = 0;
50322 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50323 wxGBSizerItem *arg2 = 0 ;
50324 bool result;
50325 void *argp1 = 0 ;
50326 int res1 = 0 ;
50327 void *argp2 = 0 ;
50328 int res2 = 0 ;
50329 PyObject * obj0 = 0 ;
50330 PyObject * obj1 = 0 ;
50331 char * kwnames[] = {
50332 (char *) "self",(char *) "other", NULL
50333 };
50334
50335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50337 if (!SWIG_IsOK(res1)) {
50338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50339 }
50340 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50341 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50342 if (!SWIG_IsOK(res2)) {
50343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50344 }
50345 if (!argp2) {
50346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50347 }
50348 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50349 {
50350 PyThreadState* __tstate = wxPyBeginAllowThreads();
50351 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50352 wxPyEndAllowThreads(__tstate);
50353 if (PyErr_Occurred()) SWIG_fail;
50354 }
50355 {
50356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50357 }
50358 return resultobj;
50359 fail:
50360 return NULL;
50361 }
50362
50363
50364 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50365 PyObject *resultobj = 0;
50366 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50367 wxGBPosition *arg2 = 0 ;
50368 wxGBSpan *arg3 = 0 ;
50369 bool result;
50370 void *argp1 = 0 ;
50371 int res1 = 0 ;
50372 wxGBPosition temp2 ;
50373 wxGBSpan temp3 ;
50374 PyObject * obj0 = 0 ;
50375 PyObject * obj1 = 0 ;
50376 PyObject * obj2 = 0 ;
50377 char * kwnames[] = {
50378 (char *) "self",(char *) "pos",(char *) "span", NULL
50379 };
50380
50381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50383 if (!SWIG_IsOK(res1)) {
50384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50385 }
50386 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50387 {
50388 arg2 = &temp2;
50389 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50390 }
50391 {
50392 arg3 = &temp3;
50393 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50394 }
50395 {
50396 PyThreadState* __tstate = wxPyBeginAllowThreads();
50397 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50398 wxPyEndAllowThreads(__tstate);
50399 if (PyErr_Occurred()) SWIG_fail;
50400 }
50401 {
50402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50403 }
50404 return resultobj;
50405 fail:
50406 return NULL;
50407 }
50408
50409
50410 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50411 PyObject *resultobj = 0;
50412 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50413 wxGBPosition result;
50414 void *argp1 = 0 ;
50415 int res1 = 0 ;
50416 PyObject *swig_obj[1] ;
50417
50418 if (!args) SWIG_fail;
50419 swig_obj[0] = args;
50420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50421 if (!SWIG_IsOK(res1)) {
50422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50423 }
50424 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50425 {
50426 PyThreadState* __tstate = wxPyBeginAllowThreads();
50427 result = wxGBSizerItem_GetEndPos(arg1);
50428 wxPyEndAllowThreads(__tstate);
50429 if (PyErr_Occurred()) SWIG_fail;
50430 }
50431 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50432 return resultobj;
50433 fail:
50434 return NULL;
50435 }
50436
50437
50438 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50439 PyObject *resultobj = 0;
50440 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50441 wxGridBagSizer *result = 0 ;
50442 void *argp1 = 0 ;
50443 int res1 = 0 ;
50444 PyObject *swig_obj[1] ;
50445
50446 if (!args) SWIG_fail;
50447 swig_obj[0] = args;
50448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50449 if (!SWIG_IsOK(res1)) {
50450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50451 }
50452 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50453 {
50454 PyThreadState* __tstate = wxPyBeginAllowThreads();
50455 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50456 wxPyEndAllowThreads(__tstate);
50457 if (PyErr_Occurred()) SWIG_fail;
50458 }
50459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50460 return resultobj;
50461 fail:
50462 return NULL;
50463 }
50464
50465
50466 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50467 PyObject *resultobj = 0;
50468 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50469 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50470 void *argp1 = 0 ;
50471 int res1 = 0 ;
50472 void *argp2 = 0 ;
50473 int res2 = 0 ;
50474 PyObject * obj0 = 0 ;
50475 PyObject * obj1 = 0 ;
50476 char * kwnames[] = {
50477 (char *) "self",(char *) "sizer", NULL
50478 };
50479
50480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50482 if (!SWIG_IsOK(res1)) {
50483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50484 }
50485 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50487 if (!SWIG_IsOK(res2)) {
50488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50489 }
50490 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50491 {
50492 PyThreadState* __tstate = wxPyBeginAllowThreads();
50493 (arg1)->SetGBSizer(arg2);
50494 wxPyEndAllowThreads(__tstate);
50495 if (PyErr_Occurred()) SWIG_fail;
50496 }
50497 resultobj = SWIG_Py_Void();
50498 return resultobj;
50499 fail:
50500 return NULL;
50501 }
50502
50503
50504 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50505 PyObject *obj;
50506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50507 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50508 return SWIG_Py_Void();
50509 }
50510
50511 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50512 return SWIG_Python_InitShadowInstance(args);
50513 }
50514
50515 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50516 PyObject *resultobj = 0;
50517 int arg1 = (int) 0 ;
50518 int arg2 = (int) 0 ;
50519 wxGridBagSizer *result = 0 ;
50520 int val1 ;
50521 int ecode1 = 0 ;
50522 int val2 ;
50523 int ecode2 = 0 ;
50524 PyObject * obj0 = 0 ;
50525 PyObject * obj1 = 0 ;
50526 char * kwnames[] = {
50527 (char *) "vgap",(char *) "hgap", NULL
50528 };
50529
50530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50531 if (obj0) {
50532 ecode1 = SWIG_AsVal_int(obj0, &val1);
50533 if (!SWIG_IsOK(ecode1)) {
50534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50535 }
50536 arg1 = static_cast< int >(val1);
50537 }
50538 if (obj1) {
50539 ecode2 = SWIG_AsVal_int(obj1, &val2);
50540 if (!SWIG_IsOK(ecode2)) {
50541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50542 }
50543 arg2 = static_cast< int >(val2);
50544 }
50545 {
50546 PyThreadState* __tstate = wxPyBeginAllowThreads();
50547 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50548 wxPyEndAllowThreads(__tstate);
50549 if (PyErr_Occurred()) SWIG_fail;
50550 }
50551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50552 return resultobj;
50553 fail:
50554 return NULL;
50555 }
50556
50557
50558 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50559 PyObject *resultobj = 0;
50560 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50561 PyObject *arg2 = (PyObject *) 0 ;
50562 wxGBPosition *arg3 = 0 ;
50563 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50564 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50565 int arg5 = (int) 0 ;
50566 int arg6 = (int) 0 ;
50567 PyObject *arg7 = (PyObject *) NULL ;
50568 wxGBSizerItem *result = 0 ;
50569 void *argp1 = 0 ;
50570 int res1 = 0 ;
50571 wxGBPosition temp3 ;
50572 wxGBSpan temp4 ;
50573 int val5 ;
50574 int ecode5 = 0 ;
50575 int val6 ;
50576 int ecode6 = 0 ;
50577 PyObject * obj0 = 0 ;
50578 PyObject * obj1 = 0 ;
50579 PyObject * obj2 = 0 ;
50580 PyObject * obj3 = 0 ;
50581 PyObject * obj4 = 0 ;
50582 PyObject * obj5 = 0 ;
50583 PyObject * obj6 = 0 ;
50584 char * kwnames[] = {
50585 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50586 };
50587
50588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50590 if (!SWIG_IsOK(res1)) {
50591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50592 }
50593 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50594 arg2 = obj1;
50595 {
50596 arg3 = &temp3;
50597 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50598 }
50599 if (obj3) {
50600 {
50601 arg4 = &temp4;
50602 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50603 }
50604 }
50605 if (obj4) {
50606 ecode5 = SWIG_AsVal_int(obj4, &val5);
50607 if (!SWIG_IsOK(ecode5)) {
50608 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50609 }
50610 arg5 = static_cast< int >(val5);
50611 }
50612 if (obj5) {
50613 ecode6 = SWIG_AsVal_int(obj5, &val6);
50614 if (!SWIG_IsOK(ecode6)) {
50615 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50616 }
50617 arg6 = static_cast< int >(val6);
50618 }
50619 if (obj6) {
50620 arg7 = obj6;
50621 }
50622 {
50623 PyThreadState* __tstate = wxPyBeginAllowThreads();
50624 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50625 wxPyEndAllowThreads(__tstate);
50626 if (PyErr_Occurred()) SWIG_fail;
50627 }
50628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50629 return resultobj;
50630 fail:
50631 return NULL;
50632 }
50633
50634
50635 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50636 PyObject *resultobj = 0;
50637 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50638 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50639 wxGBSizerItem *result = 0 ;
50640 void *argp1 = 0 ;
50641 int res1 = 0 ;
50642 int res2 = 0 ;
50643 PyObject * obj0 = 0 ;
50644 PyObject * obj1 = 0 ;
50645 char * kwnames[] = {
50646 (char *) "self",(char *) "item", NULL
50647 };
50648
50649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50651 if (!SWIG_IsOK(res1)) {
50652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50653 }
50654 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50655 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50656 if (!SWIG_IsOK(res2)) {
50657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50658 }
50659 {
50660 PyThreadState* __tstate = wxPyBeginAllowThreads();
50661 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50662 wxPyEndAllowThreads(__tstate);
50663 if (PyErr_Occurred()) SWIG_fail;
50664 }
50665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50666 return resultobj;
50667 fail:
50668 return NULL;
50669 }
50670
50671
50672 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50673 PyObject *resultobj = 0;
50674 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50675 int arg2 ;
50676 int arg3 ;
50677 wxSize result;
50678 void *argp1 = 0 ;
50679 int res1 = 0 ;
50680 int val2 ;
50681 int ecode2 = 0 ;
50682 int val3 ;
50683 int ecode3 = 0 ;
50684 PyObject * obj0 = 0 ;
50685 PyObject * obj1 = 0 ;
50686 PyObject * obj2 = 0 ;
50687 char * kwnames[] = {
50688 (char *) "self",(char *) "row",(char *) "col", NULL
50689 };
50690
50691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50693 if (!SWIG_IsOK(res1)) {
50694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50695 }
50696 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50697 ecode2 = SWIG_AsVal_int(obj1, &val2);
50698 if (!SWIG_IsOK(ecode2)) {
50699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50700 }
50701 arg2 = static_cast< int >(val2);
50702 ecode3 = SWIG_AsVal_int(obj2, &val3);
50703 if (!SWIG_IsOK(ecode3)) {
50704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50705 }
50706 arg3 = static_cast< int >(val3);
50707 {
50708 PyThreadState* __tstate = wxPyBeginAllowThreads();
50709 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50710 wxPyEndAllowThreads(__tstate);
50711 if (PyErr_Occurred()) SWIG_fail;
50712 }
50713 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50714 return resultobj;
50715 fail:
50716 return NULL;
50717 }
50718
50719
50720 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50721 PyObject *resultobj = 0;
50722 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50723 wxSize result;
50724 void *argp1 = 0 ;
50725 int res1 = 0 ;
50726 PyObject *swig_obj[1] ;
50727
50728 if (!args) SWIG_fail;
50729 swig_obj[0] = args;
50730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50731 if (!SWIG_IsOK(res1)) {
50732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50733 }
50734 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50735 {
50736 PyThreadState* __tstate = wxPyBeginAllowThreads();
50737 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50738 wxPyEndAllowThreads(__tstate);
50739 if (PyErr_Occurred()) SWIG_fail;
50740 }
50741 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50742 return resultobj;
50743 fail:
50744 return NULL;
50745 }
50746
50747
50748 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50749 PyObject *resultobj = 0;
50750 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50751 wxSize *arg2 = 0 ;
50752 void *argp1 = 0 ;
50753 int res1 = 0 ;
50754 wxSize temp2 ;
50755 PyObject * obj0 = 0 ;
50756 PyObject * obj1 = 0 ;
50757 char * kwnames[] = {
50758 (char *) "self",(char *) "sz", NULL
50759 };
50760
50761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50763 if (!SWIG_IsOK(res1)) {
50764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50765 }
50766 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50767 {
50768 arg2 = &temp2;
50769 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50770 }
50771 {
50772 PyThreadState* __tstate = wxPyBeginAllowThreads();
50773 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50774 wxPyEndAllowThreads(__tstate);
50775 if (PyErr_Occurred()) SWIG_fail;
50776 }
50777 resultobj = SWIG_Py_Void();
50778 return resultobj;
50779 fail:
50780 return NULL;
50781 }
50782
50783
50784 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50785 PyObject *resultobj = 0;
50786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50787 wxWindow *arg2 = (wxWindow *) 0 ;
50788 wxGBPosition result;
50789 void *argp1 = 0 ;
50790 int res1 = 0 ;
50791 void *argp2 = 0 ;
50792 int res2 = 0 ;
50793
50794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50796 if (!SWIG_IsOK(res1)) {
50797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50798 }
50799 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50800 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50801 if (!SWIG_IsOK(res2)) {
50802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50803 }
50804 arg2 = reinterpret_cast< wxWindow * >(argp2);
50805 {
50806 PyThreadState* __tstate = wxPyBeginAllowThreads();
50807 result = (arg1)->GetItemPosition(arg2);
50808 wxPyEndAllowThreads(__tstate);
50809 if (PyErr_Occurred()) SWIG_fail;
50810 }
50811 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50812 return resultobj;
50813 fail:
50814 return NULL;
50815 }
50816
50817
50818 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50819 PyObject *resultobj = 0;
50820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50821 wxSizer *arg2 = (wxSizer *) 0 ;
50822 wxGBPosition result;
50823 void *argp1 = 0 ;
50824 int res1 = 0 ;
50825 void *argp2 = 0 ;
50826 int res2 = 0 ;
50827
50828 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50830 if (!SWIG_IsOK(res1)) {
50831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50832 }
50833 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50834 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50835 if (!SWIG_IsOK(res2)) {
50836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50837 }
50838 arg2 = reinterpret_cast< wxSizer * >(argp2);
50839 {
50840 PyThreadState* __tstate = wxPyBeginAllowThreads();
50841 result = (arg1)->GetItemPosition(arg2);
50842 wxPyEndAllowThreads(__tstate);
50843 if (PyErr_Occurred()) SWIG_fail;
50844 }
50845 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50846 return resultobj;
50847 fail:
50848 return NULL;
50849 }
50850
50851
50852 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50853 PyObject *resultobj = 0;
50854 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50855 size_t arg2 ;
50856 wxGBPosition result;
50857 void *argp1 = 0 ;
50858 int res1 = 0 ;
50859 size_t val2 ;
50860 int ecode2 = 0 ;
50861
50862 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50864 if (!SWIG_IsOK(res1)) {
50865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50866 }
50867 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50868 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50869 if (!SWIG_IsOK(ecode2)) {
50870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50871 }
50872 arg2 = static_cast< size_t >(val2);
50873 {
50874 PyThreadState* __tstate = wxPyBeginAllowThreads();
50875 result = (arg1)->GetItemPosition(arg2);
50876 wxPyEndAllowThreads(__tstate);
50877 if (PyErr_Occurred()) SWIG_fail;
50878 }
50879 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50880 return resultobj;
50881 fail:
50882 return NULL;
50883 }
50884
50885
50886 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50887 int argc;
50888 PyObject *argv[3];
50889
50890 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50891 --argc;
50892 if (argc == 2) {
50893 int _v = 0;
50894 {
50895 void *vptr = 0;
50896 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50897 _v = SWIG_CheckState(res);
50898 }
50899 if (!_v) goto check_1;
50900 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50901 }
50902 check_1:
50903
50904 if (argc == 2) {
50905 int _v = 0;
50906 {
50907 void *vptr = 0;
50908 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50909 _v = SWIG_CheckState(res);
50910 }
50911 if (!_v) goto check_2;
50912 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50913 }
50914 check_2:
50915
50916 if (argc == 2) {
50917 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50918 }
50919
50920 fail:
50921 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50922 return NULL;
50923 }
50924
50925
50926 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50927 PyObject *resultobj = 0;
50928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50929 wxWindow *arg2 = (wxWindow *) 0 ;
50930 wxGBPosition *arg3 = 0 ;
50931 bool result;
50932 void *argp1 = 0 ;
50933 int res1 = 0 ;
50934 void *argp2 = 0 ;
50935 int res2 = 0 ;
50936 wxGBPosition temp3 ;
50937
50938 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50940 if (!SWIG_IsOK(res1)) {
50941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50942 }
50943 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50944 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50945 if (!SWIG_IsOK(res2)) {
50946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50947 }
50948 arg2 = reinterpret_cast< wxWindow * >(argp2);
50949 {
50950 arg3 = &temp3;
50951 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50952 }
50953 {
50954 PyThreadState* __tstate = wxPyBeginAllowThreads();
50955 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50956 wxPyEndAllowThreads(__tstate);
50957 if (PyErr_Occurred()) SWIG_fail;
50958 }
50959 {
50960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50961 }
50962 return resultobj;
50963 fail:
50964 return NULL;
50965 }
50966
50967
50968 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50969 PyObject *resultobj = 0;
50970 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50971 wxSizer *arg2 = (wxSizer *) 0 ;
50972 wxGBPosition *arg3 = 0 ;
50973 bool result;
50974 void *argp1 = 0 ;
50975 int res1 = 0 ;
50976 void *argp2 = 0 ;
50977 int res2 = 0 ;
50978 wxGBPosition temp3 ;
50979
50980 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50982 if (!SWIG_IsOK(res1)) {
50983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50984 }
50985 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50986 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50987 if (!SWIG_IsOK(res2)) {
50988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50989 }
50990 arg2 = reinterpret_cast< wxSizer * >(argp2);
50991 {
50992 arg3 = &temp3;
50993 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50994 }
50995 {
50996 PyThreadState* __tstate = wxPyBeginAllowThreads();
50997 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50998 wxPyEndAllowThreads(__tstate);
50999 if (PyErr_Occurred()) SWIG_fail;
51000 }
51001 {
51002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51003 }
51004 return resultobj;
51005 fail:
51006 return NULL;
51007 }
51008
51009
51010 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51011 PyObject *resultobj = 0;
51012 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51013 size_t arg2 ;
51014 wxGBPosition *arg3 = 0 ;
51015 bool result;
51016 void *argp1 = 0 ;
51017 int res1 = 0 ;
51018 size_t val2 ;
51019 int ecode2 = 0 ;
51020 wxGBPosition temp3 ;
51021
51022 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51024 if (!SWIG_IsOK(res1)) {
51025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51026 }
51027 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51028 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51029 if (!SWIG_IsOK(ecode2)) {
51030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51031 }
51032 arg2 = static_cast< size_t >(val2);
51033 {
51034 arg3 = &temp3;
51035 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51036 }
51037 {
51038 PyThreadState* __tstate = wxPyBeginAllowThreads();
51039 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51040 wxPyEndAllowThreads(__tstate);
51041 if (PyErr_Occurred()) SWIG_fail;
51042 }
51043 {
51044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51045 }
51046 return resultobj;
51047 fail:
51048 return NULL;
51049 }
51050
51051
51052 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51053 int argc;
51054 PyObject *argv[4];
51055
51056 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51057 --argc;
51058 if (argc == 3) {
51059 int _v = 0;
51060 {
51061 void *vptr = 0;
51062 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51063 _v = SWIG_CheckState(res);
51064 }
51065 if (!_v) goto check_1;
51066 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51067 }
51068 check_1:
51069
51070 if (argc == 3) {
51071 int _v = 0;
51072 {
51073 void *vptr = 0;
51074 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51075 _v = SWIG_CheckState(res);
51076 }
51077 if (!_v) goto check_2;
51078 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51079 }
51080 check_2:
51081
51082 if (argc == 3) {
51083 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51084 }
51085
51086 fail:
51087 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51088 return NULL;
51089 }
51090
51091
51092 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51093 PyObject *resultobj = 0;
51094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51095 wxWindow *arg2 = (wxWindow *) 0 ;
51096 wxGBSpan result;
51097 void *argp1 = 0 ;
51098 int res1 = 0 ;
51099 void *argp2 = 0 ;
51100 int res2 = 0 ;
51101
51102 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51104 if (!SWIG_IsOK(res1)) {
51105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51106 }
51107 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51108 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51109 if (!SWIG_IsOK(res2)) {
51110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51111 }
51112 arg2 = reinterpret_cast< wxWindow * >(argp2);
51113 {
51114 PyThreadState* __tstate = wxPyBeginAllowThreads();
51115 result = (arg1)->GetItemSpan(arg2);
51116 wxPyEndAllowThreads(__tstate);
51117 if (PyErr_Occurred()) SWIG_fail;
51118 }
51119 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51120 return resultobj;
51121 fail:
51122 return NULL;
51123 }
51124
51125
51126 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51127 PyObject *resultobj = 0;
51128 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51129 wxSizer *arg2 = (wxSizer *) 0 ;
51130 wxGBSpan result;
51131 void *argp1 = 0 ;
51132 int res1 = 0 ;
51133 void *argp2 = 0 ;
51134 int res2 = 0 ;
51135
51136 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51138 if (!SWIG_IsOK(res1)) {
51139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51140 }
51141 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51142 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51143 if (!SWIG_IsOK(res2)) {
51144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51145 }
51146 arg2 = reinterpret_cast< wxSizer * >(argp2);
51147 {
51148 PyThreadState* __tstate = wxPyBeginAllowThreads();
51149 result = (arg1)->GetItemSpan(arg2);
51150 wxPyEndAllowThreads(__tstate);
51151 if (PyErr_Occurred()) SWIG_fail;
51152 }
51153 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51154 return resultobj;
51155 fail:
51156 return NULL;
51157 }
51158
51159
51160 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51161 PyObject *resultobj = 0;
51162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51163 size_t arg2 ;
51164 wxGBSpan result;
51165 void *argp1 = 0 ;
51166 int res1 = 0 ;
51167 size_t val2 ;
51168 int ecode2 = 0 ;
51169
51170 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51172 if (!SWIG_IsOK(res1)) {
51173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51174 }
51175 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51176 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51177 if (!SWIG_IsOK(ecode2)) {
51178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51179 }
51180 arg2 = static_cast< size_t >(val2);
51181 {
51182 PyThreadState* __tstate = wxPyBeginAllowThreads();
51183 result = (arg1)->GetItemSpan(arg2);
51184 wxPyEndAllowThreads(__tstate);
51185 if (PyErr_Occurred()) SWIG_fail;
51186 }
51187 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51188 return resultobj;
51189 fail:
51190 return NULL;
51191 }
51192
51193
51194 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51195 int argc;
51196 PyObject *argv[3];
51197
51198 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51199 --argc;
51200 if (argc == 2) {
51201 int _v = 0;
51202 {
51203 void *vptr = 0;
51204 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51205 _v = SWIG_CheckState(res);
51206 }
51207 if (!_v) goto check_1;
51208 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51209 }
51210 check_1:
51211
51212 if (argc == 2) {
51213 int _v = 0;
51214 {
51215 void *vptr = 0;
51216 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51217 _v = SWIG_CheckState(res);
51218 }
51219 if (!_v) goto check_2;
51220 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51221 }
51222 check_2:
51223
51224 if (argc == 2) {
51225 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51226 }
51227
51228 fail:
51229 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51230 return NULL;
51231 }
51232
51233
51234 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51235 PyObject *resultobj = 0;
51236 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51237 wxWindow *arg2 = (wxWindow *) 0 ;
51238 wxGBSpan *arg3 = 0 ;
51239 bool result;
51240 void *argp1 = 0 ;
51241 int res1 = 0 ;
51242 void *argp2 = 0 ;
51243 int res2 = 0 ;
51244 wxGBSpan temp3 ;
51245
51246 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51250 }
51251 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51252 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51253 if (!SWIG_IsOK(res2)) {
51254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51255 }
51256 arg2 = reinterpret_cast< wxWindow * >(argp2);
51257 {
51258 arg3 = &temp3;
51259 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51260 }
51261 {
51262 PyThreadState* __tstate = wxPyBeginAllowThreads();
51263 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51264 wxPyEndAllowThreads(__tstate);
51265 if (PyErr_Occurred()) SWIG_fail;
51266 }
51267 {
51268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51269 }
51270 return resultobj;
51271 fail:
51272 return NULL;
51273 }
51274
51275
51276 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51277 PyObject *resultobj = 0;
51278 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51279 wxSizer *arg2 = (wxSizer *) 0 ;
51280 wxGBSpan *arg3 = 0 ;
51281 bool result;
51282 void *argp1 = 0 ;
51283 int res1 = 0 ;
51284 void *argp2 = 0 ;
51285 int res2 = 0 ;
51286 wxGBSpan temp3 ;
51287
51288 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51290 if (!SWIG_IsOK(res1)) {
51291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51292 }
51293 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51294 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51295 if (!SWIG_IsOK(res2)) {
51296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51297 }
51298 arg2 = reinterpret_cast< wxSizer * >(argp2);
51299 {
51300 arg3 = &temp3;
51301 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51302 }
51303 {
51304 PyThreadState* __tstate = wxPyBeginAllowThreads();
51305 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51306 wxPyEndAllowThreads(__tstate);
51307 if (PyErr_Occurred()) SWIG_fail;
51308 }
51309 {
51310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51311 }
51312 return resultobj;
51313 fail:
51314 return NULL;
51315 }
51316
51317
51318 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51319 PyObject *resultobj = 0;
51320 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51321 size_t arg2 ;
51322 wxGBSpan *arg3 = 0 ;
51323 bool result;
51324 void *argp1 = 0 ;
51325 int res1 = 0 ;
51326 size_t val2 ;
51327 int ecode2 = 0 ;
51328 wxGBSpan temp3 ;
51329
51330 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51334 }
51335 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51336 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51337 if (!SWIG_IsOK(ecode2)) {
51338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51339 }
51340 arg2 = static_cast< size_t >(val2);
51341 {
51342 arg3 = &temp3;
51343 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51344 }
51345 {
51346 PyThreadState* __tstate = wxPyBeginAllowThreads();
51347 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51348 wxPyEndAllowThreads(__tstate);
51349 if (PyErr_Occurred()) SWIG_fail;
51350 }
51351 {
51352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51353 }
51354 return resultobj;
51355 fail:
51356 return NULL;
51357 }
51358
51359
51360 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51361 int argc;
51362 PyObject *argv[4];
51363
51364 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51365 --argc;
51366 if (argc == 3) {
51367 int _v = 0;
51368 {
51369 void *vptr = 0;
51370 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51371 _v = SWIG_CheckState(res);
51372 }
51373 if (!_v) goto check_1;
51374 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51375 }
51376 check_1:
51377
51378 if (argc == 3) {
51379 int _v = 0;
51380 {
51381 void *vptr = 0;
51382 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51383 _v = SWIG_CheckState(res);
51384 }
51385 if (!_v) goto check_2;
51386 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51387 }
51388 check_2:
51389
51390 if (argc == 3) {
51391 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51392 }
51393
51394 fail:
51395 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51396 return NULL;
51397 }
51398
51399
51400 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51401 PyObject *resultobj = 0;
51402 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51403 wxWindow *arg2 = (wxWindow *) 0 ;
51404 wxGBSizerItem *result = 0 ;
51405 void *argp1 = 0 ;
51406 int res1 = 0 ;
51407 void *argp2 = 0 ;
51408 int res2 = 0 ;
51409
51410 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51412 if (!SWIG_IsOK(res1)) {
51413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51414 }
51415 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51416 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51417 if (!SWIG_IsOK(res2)) {
51418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51419 }
51420 arg2 = reinterpret_cast< wxWindow * >(argp2);
51421 {
51422 PyThreadState* __tstate = wxPyBeginAllowThreads();
51423 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51424 wxPyEndAllowThreads(__tstate);
51425 if (PyErr_Occurred()) SWIG_fail;
51426 }
51427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51428 return resultobj;
51429 fail:
51430 return NULL;
51431 }
51432
51433
51434 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51435 PyObject *resultobj = 0;
51436 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51437 wxSizer *arg2 = (wxSizer *) 0 ;
51438 wxGBSizerItem *result = 0 ;
51439 void *argp1 = 0 ;
51440 int res1 = 0 ;
51441 void *argp2 = 0 ;
51442 int res2 = 0 ;
51443
51444 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51446 if (!SWIG_IsOK(res1)) {
51447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51448 }
51449 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51450 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51451 if (!SWIG_IsOK(res2)) {
51452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51453 }
51454 arg2 = reinterpret_cast< wxSizer * >(argp2);
51455 {
51456 PyThreadState* __tstate = wxPyBeginAllowThreads();
51457 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51458 wxPyEndAllowThreads(__tstate);
51459 if (PyErr_Occurred()) SWIG_fail;
51460 }
51461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51462 return resultobj;
51463 fail:
51464 return NULL;
51465 }
51466
51467
51468 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51469 int argc;
51470 PyObject *argv[3];
51471
51472 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51473 --argc;
51474 if (argc == 2) {
51475 int _v = 0;
51476 {
51477 void *vptr = 0;
51478 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51479 _v = SWIG_CheckState(res);
51480 }
51481 if (!_v) goto check_1;
51482 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51483 }
51484 check_1:
51485
51486 if (argc == 2) {
51487 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51488 }
51489
51490 fail:
51491 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51492 return NULL;
51493 }
51494
51495
51496 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51497 PyObject *resultobj = 0;
51498 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51499 wxGBPosition *arg2 = 0 ;
51500 wxGBSizerItem *result = 0 ;
51501 void *argp1 = 0 ;
51502 int res1 = 0 ;
51503 wxGBPosition temp2 ;
51504 PyObject * obj0 = 0 ;
51505 PyObject * obj1 = 0 ;
51506 char * kwnames[] = {
51507 (char *) "self",(char *) "pos", NULL
51508 };
51509
51510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51512 if (!SWIG_IsOK(res1)) {
51513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51514 }
51515 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51516 {
51517 arg2 = &temp2;
51518 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51519 }
51520 {
51521 PyThreadState* __tstate = wxPyBeginAllowThreads();
51522 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51523 wxPyEndAllowThreads(__tstate);
51524 if (PyErr_Occurred()) SWIG_fail;
51525 }
51526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51527 return resultobj;
51528 fail:
51529 return NULL;
51530 }
51531
51532
51533 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51534 PyObject *resultobj = 0;
51535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51536 wxPoint *arg2 = 0 ;
51537 wxGBSizerItem *result = 0 ;
51538 void *argp1 = 0 ;
51539 int res1 = 0 ;
51540 wxPoint temp2 ;
51541 PyObject * obj0 = 0 ;
51542 PyObject * obj1 = 0 ;
51543 char * kwnames[] = {
51544 (char *) "self",(char *) "pt", NULL
51545 };
51546
51547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51549 if (!SWIG_IsOK(res1)) {
51550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51551 }
51552 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51553 {
51554 arg2 = &temp2;
51555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51556 }
51557 {
51558 PyThreadState* __tstate = wxPyBeginAllowThreads();
51559 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51560 wxPyEndAllowThreads(__tstate);
51561 if (PyErr_Occurred()) SWIG_fail;
51562 }
51563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51564 return resultobj;
51565 fail:
51566 return NULL;
51567 }
51568
51569
51570 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51571 PyObject *resultobj = 0;
51572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51573 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51574 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51575 bool result;
51576 void *argp1 = 0 ;
51577 int res1 = 0 ;
51578 void *argp2 = 0 ;
51579 int res2 = 0 ;
51580 void *argp3 = 0 ;
51581 int res3 = 0 ;
51582 PyObject * obj0 = 0 ;
51583 PyObject * obj1 = 0 ;
51584 PyObject * obj2 = 0 ;
51585 char * kwnames[] = {
51586 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51587 };
51588
51589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51591 if (!SWIG_IsOK(res1)) {
51592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51593 }
51594 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51596 if (!SWIG_IsOK(res2)) {
51597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51598 }
51599 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51600 if (obj2) {
51601 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51602 if (!SWIG_IsOK(res3)) {
51603 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51604 }
51605 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51606 }
51607 {
51608 PyThreadState* __tstate = wxPyBeginAllowThreads();
51609 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51610 wxPyEndAllowThreads(__tstate);
51611 if (PyErr_Occurred()) SWIG_fail;
51612 }
51613 {
51614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51615 }
51616 return resultobj;
51617 fail:
51618 return NULL;
51619 }
51620
51621
51622 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51623 PyObject *resultobj = 0;
51624 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51625 wxGBPosition *arg2 = 0 ;
51626 wxGBSpan *arg3 = 0 ;
51627 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51628 bool result;
51629 void *argp1 = 0 ;
51630 int res1 = 0 ;
51631 wxGBPosition temp2 ;
51632 wxGBSpan temp3 ;
51633 void *argp4 = 0 ;
51634 int res4 = 0 ;
51635 PyObject * obj0 = 0 ;
51636 PyObject * obj1 = 0 ;
51637 PyObject * obj2 = 0 ;
51638 PyObject * obj3 = 0 ;
51639 char * kwnames[] = {
51640 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51641 };
51642
51643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51645 if (!SWIG_IsOK(res1)) {
51646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51647 }
51648 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51649 {
51650 arg2 = &temp2;
51651 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51652 }
51653 {
51654 arg3 = &temp3;
51655 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51656 }
51657 if (obj3) {
51658 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51659 if (!SWIG_IsOK(res4)) {
51660 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51661 }
51662 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51663 }
51664 {
51665 PyThreadState* __tstate = wxPyBeginAllowThreads();
51666 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51667 wxPyEndAllowThreads(__tstate);
51668 if (PyErr_Occurred()) SWIG_fail;
51669 }
51670 {
51671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51672 }
51673 return resultobj;
51674 fail:
51675 return NULL;
51676 }
51677
51678
51679 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51680 PyObject *obj;
51681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51682 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51683 return SWIG_Py_Void();
51684 }
51685
51686 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51687 return SWIG_Python_InitShadowInstance(args);
51688 }
51689
51690 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51691 PyObject *resultobj = 0;
51692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51693 wxRelationship arg2 ;
51694 wxWindow *arg3 = (wxWindow *) 0 ;
51695 wxEdge arg4 ;
51696 int arg5 = (int) 0 ;
51697 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51698 void *argp1 = 0 ;
51699 int res1 = 0 ;
51700 int val2 ;
51701 int ecode2 = 0 ;
51702 void *argp3 = 0 ;
51703 int res3 = 0 ;
51704 int val4 ;
51705 int ecode4 = 0 ;
51706 int val5 ;
51707 int ecode5 = 0 ;
51708 int val6 ;
51709 int ecode6 = 0 ;
51710 PyObject * obj0 = 0 ;
51711 PyObject * obj1 = 0 ;
51712 PyObject * obj2 = 0 ;
51713 PyObject * obj3 = 0 ;
51714 PyObject * obj4 = 0 ;
51715 PyObject * obj5 = 0 ;
51716 char * kwnames[] = {
51717 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51718 };
51719
51720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51722 if (!SWIG_IsOK(res1)) {
51723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51724 }
51725 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51726 ecode2 = SWIG_AsVal_int(obj1, &val2);
51727 if (!SWIG_IsOK(ecode2)) {
51728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51729 }
51730 arg2 = static_cast< wxRelationship >(val2);
51731 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51732 if (!SWIG_IsOK(res3)) {
51733 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51734 }
51735 arg3 = reinterpret_cast< wxWindow * >(argp3);
51736 ecode4 = SWIG_AsVal_int(obj3, &val4);
51737 if (!SWIG_IsOK(ecode4)) {
51738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51739 }
51740 arg4 = static_cast< wxEdge >(val4);
51741 if (obj4) {
51742 ecode5 = SWIG_AsVal_int(obj4, &val5);
51743 if (!SWIG_IsOK(ecode5)) {
51744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51745 }
51746 arg5 = static_cast< int >(val5);
51747 }
51748 if (obj5) {
51749 ecode6 = SWIG_AsVal_int(obj5, &val6);
51750 if (!SWIG_IsOK(ecode6)) {
51751 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51752 }
51753 arg6 = static_cast< int >(val6);
51754 }
51755 {
51756 PyThreadState* __tstate = wxPyBeginAllowThreads();
51757 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51758 wxPyEndAllowThreads(__tstate);
51759 if (PyErr_Occurred()) SWIG_fail;
51760 }
51761 resultobj = SWIG_Py_Void();
51762 return resultobj;
51763 fail:
51764 return NULL;
51765 }
51766
51767
51768 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51769 PyObject *resultobj = 0;
51770 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51771 wxWindow *arg2 = (wxWindow *) 0 ;
51772 int arg3 = (int) 0 ;
51773 void *argp1 = 0 ;
51774 int res1 = 0 ;
51775 void *argp2 = 0 ;
51776 int res2 = 0 ;
51777 int val3 ;
51778 int ecode3 = 0 ;
51779 PyObject * obj0 = 0 ;
51780 PyObject * obj1 = 0 ;
51781 PyObject * obj2 = 0 ;
51782 char * kwnames[] = {
51783 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51784 };
51785
51786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51788 if (!SWIG_IsOK(res1)) {
51789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51790 }
51791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51793 if (!SWIG_IsOK(res2)) {
51794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51795 }
51796 arg2 = reinterpret_cast< wxWindow * >(argp2);
51797 if (obj2) {
51798 ecode3 = SWIG_AsVal_int(obj2, &val3);
51799 if (!SWIG_IsOK(ecode3)) {
51800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51801 }
51802 arg3 = static_cast< int >(val3);
51803 }
51804 {
51805 PyThreadState* __tstate = wxPyBeginAllowThreads();
51806 (arg1)->LeftOf(arg2,arg3);
51807 wxPyEndAllowThreads(__tstate);
51808 if (PyErr_Occurred()) SWIG_fail;
51809 }
51810 resultobj = SWIG_Py_Void();
51811 return resultobj;
51812 fail:
51813 return NULL;
51814 }
51815
51816
51817 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51818 PyObject *resultobj = 0;
51819 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51820 wxWindow *arg2 = (wxWindow *) 0 ;
51821 int arg3 = (int) 0 ;
51822 void *argp1 = 0 ;
51823 int res1 = 0 ;
51824 void *argp2 = 0 ;
51825 int res2 = 0 ;
51826 int val3 ;
51827 int ecode3 = 0 ;
51828 PyObject * obj0 = 0 ;
51829 PyObject * obj1 = 0 ;
51830 PyObject * obj2 = 0 ;
51831 char * kwnames[] = {
51832 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51833 };
51834
51835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51837 if (!SWIG_IsOK(res1)) {
51838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51839 }
51840 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51842 if (!SWIG_IsOK(res2)) {
51843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51844 }
51845 arg2 = reinterpret_cast< wxWindow * >(argp2);
51846 if (obj2) {
51847 ecode3 = SWIG_AsVal_int(obj2, &val3);
51848 if (!SWIG_IsOK(ecode3)) {
51849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51850 }
51851 arg3 = static_cast< int >(val3);
51852 }
51853 {
51854 PyThreadState* __tstate = wxPyBeginAllowThreads();
51855 (arg1)->RightOf(arg2,arg3);
51856 wxPyEndAllowThreads(__tstate);
51857 if (PyErr_Occurred()) SWIG_fail;
51858 }
51859 resultobj = SWIG_Py_Void();
51860 return resultobj;
51861 fail:
51862 return NULL;
51863 }
51864
51865
51866 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51867 PyObject *resultobj = 0;
51868 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51869 wxWindow *arg2 = (wxWindow *) 0 ;
51870 int arg3 = (int) 0 ;
51871 void *argp1 = 0 ;
51872 int res1 = 0 ;
51873 void *argp2 = 0 ;
51874 int res2 = 0 ;
51875 int val3 ;
51876 int ecode3 = 0 ;
51877 PyObject * obj0 = 0 ;
51878 PyObject * obj1 = 0 ;
51879 PyObject * obj2 = 0 ;
51880 char * kwnames[] = {
51881 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51882 };
51883
51884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51886 if (!SWIG_IsOK(res1)) {
51887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51888 }
51889 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51891 if (!SWIG_IsOK(res2)) {
51892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51893 }
51894 arg2 = reinterpret_cast< wxWindow * >(argp2);
51895 if (obj2) {
51896 ecode3 = SWIG_AsVal_int(obj2, &val3);
51897 if (!SWIG_IsOK(ecode3)) {
51898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51899 }
51900 arg3 = static_cast< int >(val3);
51901 }
51902 {
51903 PyThreadState* __tstate = wxPyBeginAllowThreads();
51904 (arg1)->Above(arg2,arg3);
51905 wxPyEndAllowThreads(__tstate);
51906 if (PyErr_Occurred()) SWIG_fail;
51907 }
51908 resultobj = SWIG_Py_Void();
51909 return resultobj;
51910 fail:
51911 return NULL;
51912 }
51913
51914
51915 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51916 PyObject *resultobj = 0;
51917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51918 wxWindow *arg2 = (wxWindow *) 0 ;
51919 int arg3 = (int) 0 ;
51920 void *argp1 = 0 ;
51921 int res1 = 0 ;
51922 void *argp2 = 0 ;
51923 int res2 = 0 ;
51924 int val3 ;
51925 int ecode3 = 0 ;
51926 PyObject * obj0 = 0 ;
51927 PyObject * obj1 = 0 ;
51928 PyObject * obj2 = 0 ;
51929 char * kwnames[] = {
51930 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51931 };
51932
51933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51935 if (!SWIG_IsOK(res1)) {
51936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51937 }
51938 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51940 if (!SWIG_IsOK(res2)) {
51941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51942 }
51943 arg2 = reinterpret_cast< wxWindow * >(argp2);
51944 if (obj2) {
51945 ecode3 = SWIG_AsVal_int(obj2, &val3);
51946 if (!SWIG_IsOK(ecode3)) {
51947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51948 }
51949 arg3 = static_cast< int >(val3);
51950 }
51951 {
51952 PyThreadState* __tstate = wxPyBeginAllowThreads();
51953 (arg1)->Below(arg2,arg3);
51954 wxPyEndAllowThreads(__tstate);
51955 if (PyErr_Occurred()) SWIG_fail;
51956 }
51957 resultobj = SWIG_Py_Void();
51958 return resultobj;
51959 fail:
51960 return NULL;
51961 }
51962
51963
51964 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51965 PyObject *resultobj = 0;
51966 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51967 wxWindow *arg2 = (wxWindow *) 0 ;
51968 wxEdge arg3 ;
51969 int arg4 = (int) 0 ;
51970 void *argp1 = 0 ;
51971 int res1 = 0 ;
51972 void *argp2 = 0 ;
51973 int res2 = 0 ;
51974 int val3 ;
51975 int ecode3 = 0 ;
51976 int val4 ;
51977 int ecode4 = 0 ;
51978 PyObject * obj0 = 0 ;
51979 PyObject * obj1 = 0 ;
51980 PyObject * obj2 = 0 ;
51981 PyObject * obj3 = 0 ;
51982 char * kwnames[] = {
51983 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51984 };
51985
51986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51988 if (!SWIG_IsOK(res1)) {
51989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51990 }
51991 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51993 if (!SWIG_IsOK(res2)) {
51994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51995 }
51996 arg2 = reinterpret_cast< wxWindow * >(argp2);
51997 ecode3 = SWIG_AsVal_int(obj2, &val3);
51998 if (!SWIG_IsOK(ecode3)) {
51999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52000 }
52001 arg3 = static_cast< wxEdge >(val3);
52002 if (obj3) {
52003 ecode4 = SWIG_AsVal_int(obj3, &val4);
52004 if (!SWIG_IsOK(ecode4)) {
52005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52006 }
52007 arg4 = static_cast< int >(val4);
52008 }
52009 {
52010 PyThreadState* __tstate = wxPyBeginAllowThreads();
52011 (arg1)->SameAs(arg2,arg3,arg4);
52012 wxPyEndAllowThreads(__tstate);
52013 if (PyErr_Occurred()) SWIG_fail;
52014 }
52015 resultobj = SWIG_Py_Void();
52016 return resultobj;
52017 fail:
52018 return NULL;
52019 }
52020
52021
52022 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52023 PyObject *resultobj = 0;
52024 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52025 wxWindow *arg2 = (wxWindow *) 0 ;
52026 wxEdge arg3 ;
52027 int arg4 ;
52028 void *argp1 = 0 ;
52029 int res1 = 0 ;
52030 void *argp2 = 0 ;
52031 int res2 = 0 ;
52032 int val3 ;
52033 int ecode3 = 0 ;
52034 int val4 ;
52035 int ecode4 = 0 ;
52036 PyObject * obj0 = 0 ;
52037 PyObject * obj1 = 0 ;
52038 PyObject * obj2 = 0 ;
52039 PyObject * obj3 = 0 ;
52040 char * kwnames[] = {
52041 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52042 };
52043
52044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52046 if (!SWIG_IsOK(res1)) {
52047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52048 }
52049 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52051 if (!SWIG_IsOK(res2)) {
52052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52053 }
52054 arg2 = reinterpret_cast< wxWindow * >(argp2);
52055 ecode3 = SWIG_AsVal_int(obj2, &val3);
52056 if (!SWIG_IsOK(ecode3)) {
52057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52058 }
52059 arg3 = static_cast< wxEdge >(val3);
52060 ecode4 = SWIG_AsVal_int(obj3, &val4);
52061 if (!SWIG_IsOK(ecode4)) {
52062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52063 }
52064 arg4 = static_cast< int >(val4);
52065 {
52066 PyThreadState* __tstate = wxPyBeginAllowThreads();
52067 (arg1)->PercentOf(arg2,arg3,arg4);
52068 wxPyEndAllowThreads(__tstate);
52069 if (PyErr_Occurred()) SWIG_fail;
52070 }
52071 resultobj = SWIG_Py_Void();
52072 return resultobj;
52073 fail:
52074 return NULL;
52075 }
52076
52077
52078 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52079 PyObject *resultobj = 0;
52080 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52081 int arg2 ;
52082 void *argp1 = 0 ;
52083 int res1 = 0 ;
52084 int val2 ;
52085 int ecode2 = 0 ;
52086 PyObject * obj0 = 0 ;
52087 PyObject * obj1 = 0 ;
52088 char * kwnames[] = {
52089 (char *) "self",(char *) "val", NULL
52090 };
52091
52092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52094 if (!SWIG_IsOK(res1)) {
52095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52096 }
52097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52098 ecode2 = SWIG_AsVal_int(obj1, &val2);
52099 if (!SWIG_IsOK(ecode2)) {
52100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52101 }
52102 arg2 = static_cast< int >(val2);
52103 {
52104 PyThreadState* __tstate = wxPyBeginAllowThreads();
52105 (arg1)->Absolute(arg2);
52106 wxPyEndAllowThreads(__tstate);
52107 if (PyErr_Occurred()) SWIG_fail;
52108 }
52109 resultobj = SWIG_Py_Void();
52110 return resultobj;
52111 fail:
52112 return NULL;
52113 }
52114
52115
52116 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52117 PyObject *resultobj = 0;
52118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
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_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52128 }
52129 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52130 {
52131 PyThreadState* __tstate = wxPyBeginAllowThreads();
52132 (arg1)->Unconstrained();
52133 wxPyEndAllowThreads(__tstate);
52134 if (PyErr_Occurred()) SWIG_fail;
52135 }
52136 resultobj = SWIG_Py_Void();
52137 return resultobj;
52138 fail:
52139 return NULL;
52140 }
52141
52142
52143 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *resultobj = 0;
52145 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52146 void *argp1 = 0 ;
52147 int res1 = 0 ;
52148 PyObject *swig_obj[1] ;
52149
52150 if (!args) SWIG_fail;
52151 swig_obj[0] = args;
52152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52153 if (!SWIG_IsOK(res1)) {
52154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52155 }
52156 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52157 {
52158 PyThreadState* __tstate = wxPyBeginAllowThreads();
52159 (arg1)->AsIs();
52160 wxPyEndAllowThreads(__tstate);
52161 if (PyErr_Occurred()) SWIG_fail;
52162 }
52163 resultobj = SWIG_Py_Void();
52164 return resultobj;
52165 fail:
52166 return NULL;
52167 }
52168
52169
52170 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52171 PyObject *resultobj = 0;
52172 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52173 wxWindow *result = 0 ;
52174 void *argp1 = 0 ;
52175 int res1 = 0 ;
52176 PyObject *swig_obj[1] ;
52177
52178 if (!args) SWIG_fail;
52179 swig_obj[0] = args;
52180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52181 if (!SWIG_IsOK(res1)) {
52182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52183 }
52184 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52185 {
52186 PyThreadState* __tstate = wxPyBeginAllowThreads();
52187 result = (wxWindow *)(arg1)->GetOtherWindow();
52188 wxPyEndAllowThreads(__tstate);
52189 if (PyErr_Occurred()) SWIG_fail;
52190 }
52191 {
52192 resultobj = wxPyMake_wxObject(result, 0);
52193 }
52194 return resultobj;
52195 fail:
52196 return NULL;
52197 }
52198
52199
52200 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52201 PyObject *resultobj = 0;
52202 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52203 wxEdge result;
52204 void *argp1 = 0 ;
52205 int res1 = 0 ;
52206 PyObject *swig_obj[1] ;
52207
52208 if (!args) SWIG_fail;
52209 swig_obj[0] = args;
52210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52211 if (!SWIG_IsOK(res1)) {
52212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52213 }
52214 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 resultobj = SWIG_From_int(static_cast< int >(result));
52222 return resultobj;
52223 fail:
52224 return NULL;
52225 }
52226
52227
52228 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52229 PyObject *resultobj = 0;
52230 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52231 wxEdge arg2 ;
52232 void *argp1 = 0 ;
52233 int res1 = 0 ;
52234 int val2 ;
52235 int ecode2 = 0 ;
52236 PyObject * obj0 = 0 ;
52237 PyObject * obj1 = 0 ;
52238 char * kwnames[] = {
52239 (char *) "self",(char *) "which", NULL
52240 };
52241
52242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52244 if (!SWIG_IsOK(res1)) {
52245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52246 }
52247 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52248 ecode2 = SWIG_AsVal_int(obj1, &val2);
52249 if (!SWIG_IsOK(ecode2)) {
52250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52251 }
52252 arg2 = static_cast< wxEdge >(val2);
52253 {
52254 PyThreadState* __tstate = wxPyBeginAllowThreads();
52255 (arg1)->SetEdge(arg2);
52256 wxPyEndAllowThreads(__tstate);
52257 if (PyErr_Occurred()) SWIG_fail;
52258 }
52259 resultobj = SWIG_Py_Void();
52260 return resultobj;
52261 fail:
52262 return NULL;
52263 }
52264
52265
52266 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52267 PyObject *resultobj = 0;
52268 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52269 int arg2 ;
52270 void *argp1 = 0 ;
52271 int res1 = 0 ;
52272 int val2 ;
52273 int ecode2 = 0 ;
52274 PyObject * obj0 = 0 ;
52275 PyObject * obj1 = 0 ;
52276 char * kwnames[] = {
52277 (char *) "self",(char *) "v", NULL
52278 };
52279
52280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52282 if (!SWIG_IsOK(res1)) {
52283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52284 }
52285 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52286 ecode2 = SWIG_AsVal_int(obj1, &val2);
52287 if (!SWIG_IsOK(ecode2)) {
52288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52289 }
52290 arg2 = static_cast< int >(val2);
52291 {
52292 PyThreadState* __tstate = wxPyBeginAllowThreads();
52293 (arg1)->SetValue(arg2);
52294 wxPyEndAllowThreads(__tstate);
52295 if (PyErr_Occurred()) SWIG_fail;
52296 }
52297 resultobj = SWIG_Py_Void();
52298 return resultobj;
52299 fail:
52300 return NULL;
52301 }
52302
52303
52304 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52305 PyObject *resultobj = 0;
52306 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52307 int result;
52308 void *argp1 = 0 ;
52309 int res1 = 0 ;
52310 PyObject *swig_obj[1] ;
52311
52312 if (!args) SWIG_fail;
52313 swig_obj[0] = args;
52314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52315 if (!SWIG_IsOK(res1)) {
52316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52317 }
52318 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52319 {
52320 PyThreadState* __tstate = wxPyBeginAllowThreads();
52321 result = (int)(arg1)->GetMargin();
52322 wxPyEndAllowThreads(__tstate);
52323 if (PyErr_Occurred()) SWIG_fail;
52324 }
52325 resultobj = SWIG_From_int(static_cast< int >(result));
52326 return resultobj;
52327 fail:
52328 return NULL;
52329 }
52330
52331
52332 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52333 PyObject *resultobj = 0;
52334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52335 int arg2 ;
52336 void *argp1 = 0 ;
52337 int res1 = 0 ;
52338 int val2 ;
52339 int ecode2 = 0 ;
52340 PyObject * obj0 = 0 ;
52341 PyObject * obj1 = 0 ;
52342 char * kwnames[] = {
52343 (char *) "self",(char *) "m", NULL
52344 };
52345
52346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52348 if (!SWIG_IsOK(res1)) {
52349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52350 }
52351 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52352 ecode2 = SWIG_AsVal_int(obj1, &val2);
52353 if (!SWIG_IsOK(ecode2)) {
52354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52355 }
52356 arg2 = static_cast< int >(val2);
52357 {
52358 PyThreadState* __tstate = wxPyBeginAllowThreads();
52359 (arg1)->SetMargin(arg2);
52360 wxPyEndAllowThreads(__tstate);
52361 if (PyErr_Occurred()) SWIG_fail;
52362 }
52363 resultobj = SWIG_Py_Void();
52364 return resultobj;
52365 fail:
52366 return NULL;
52367 }
52368
52369
52370 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52371 PyObject *resultobj = 0;
52372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52373 int result;
52374 void *argp1 = 0 ;
52375 int res1 = 0 ;
52376 PyObject *swig_obj[1] ;
52377
52378 if (!args) SWIG_fail;
52379 swig_obj[0] = args;
52380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52381 if (!SWIG_IsOK(res1)) {
52382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52383 }
52384 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52385 {
52386 PyThreadState* __tstate = wxPyBeginAllowThreads();
52387 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52388 wxPyEndAllowThreads(__tstate);
52389 if (PyErr_Occurred()) SWIG_fail;
52390 }
52391 resultobj = SWIG_From_int(static_cast< int >(result));
52392 return resultobj;
52393 fail:
52394 return NULL;
52395 }
52396
52397
52398 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52399 PyObject *resultobj = 0;
52400 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52401 int result;
52402 void *argp1 = 0 ;
52403 int res1 = 0 ;
52404 PyObject *swig_obj[1] ;
52405
52406 if (!args) SWIG_fail;
52407 swig_obj[0] = args;
52408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52409 if (!SWIG_IsOK(res1)) {
52410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52411 }
52412 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52413 {
52414 PyThreadState* __tstate = wxPyBeginAllowThreads();
52415 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52416 wxPyEndAllowThreads(__tstate);
52417 if (PyErr_Occurred()) SWIG_fail;
52418 }
52419 resultobj = SWIG_From_int(static_cast< int >(result));
52420 return resultobj;
52421 fail:
52422 return NULL;
52423 }
52424
52425
52426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52427 PyObject *resultobj = 0;
52428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52429 int result;
52430 void *argp1 = 0 ;
52431 int res1 = 0 ;
52432 PyObject *swig_obj[1] ;
52433
52434 if (!args) SWIG_fail;
52435 swig_obj[0] = args;
52436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52437 if (!SWIG_IsOK(res1)) {
52438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52439 }
52440 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52441 {
52442 PyThreadState* __tstate = wxPyBeginAllowThreads();
52443 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52444 wxPyEndAllowThreads(__tstate);
52445 if (PyErr_Occurred()) SWIG_fail;
52446 }
52447 resultobj = SWIG_From_int(static_cast< int >(result));
52448 return resultobj;
52449 fail:
52450 return NULL;
52451 }
52452
52453
52454 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52455 PyObject *resultobj = 0;
52456 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52457 bool result;
52458 void *argp1 = 0 ;
52459 int res1 = 0 ;
52460 PyObject *swig_obj[1] ;
52461
52462 if (!args) SWIG_fail;
52463 swig_obj[0] = args;
52464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52465 if (!SWIG_IsOK(res1)) {
52466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52467 }
52468 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52469 {
52470 PyThreadState* __tstate = wxPyBeginAllowThreads();
52471 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52472 wxPyEndAllowThreads(__tstate);
52473 if (PyErr_Occurred()) SWIG_fail;
52474 }
52475 {
52476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52477 }
52478 return resultobj;
52479 fail:
52480 return NULL;
52481 }
52482
52483
52484 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52485 PyObject *resultobj = 0;
52486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52487 bool arg2 ;
52488 void *argp1 = 0 ;
52489 int res1 = 0 ;
52490 bool val2 ;
52491 int ecode2 = 0 ;
52492 PyObject * obj0 = 0 ;
52493 PyObject * obj1 = 0 ;
52494 char * kwnames[] = {
52495 (char *) "self",(char *) "d", NULL
52496 };
52497
52498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52500 if (!SWIG_IsOK(res1)) {
52501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52502 }
52503 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52504 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52505 if (!SWIG_IsOK(ecode2)) {
52506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52507 }
52508 arg2 = static_cast< bool >(val2);
52509 {
52510 PyThreadState* __tstate = wxPyBeginAllowThreads();
52511 (arg1)->SetDone(arg2);
52512 wxPyEndAllowThreads(__tstate);
52513 if (PyErr_Occurred()) SWIG_fail;
52514 }
52515 resultobj = SWIG_Py_Void();
52516 return resultobj;
52517 fail:
52518 return NULL;
52519 }
52520
52521
52522 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52523 PyObject *resultobj = 0;
52524 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52525 wxRelationship result;
52526 void *argp1 = 0 ;
52527 int res1 = 0 ;
52528 PyObject *swig_obj[1] ;
52529
52530 if (!args) SWIG_fail;
52531 swig_obj[0] = args;
52532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52533 if (!SWIG_IsOK(res1)) {
52534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52535 }
52536 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52537 {
52538 PyThreadState* __tstate = wxPyBeginAllowThreads();
52539 result = (wxRelationship)(arg1)->GetRelationship();
52540 wxPyEndAllowThreads(__tstate);
52541 if (PyErr_Occurred()) SWIG_fail;
52542 }
52543 resultobj = SWIG_From_int(static_cast< int >(result));
52544 return resultobj;
52545 fail:
52546 return NULL;
52547 }
52548
52549
52550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52551 PyObject *resultobj = 0;
52552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52553 wxRelationship arg2 ;
52554 void *argp1 = 0 ;
52555 int res1 = 0 ;
52556 int val2 ;
52557 int ecode2 = 0 ;
52558 PyObject * obj0 = 0 ;
52559 PyObject * obj1 = 0 ;
52560 char * kwnames[] = {
52561 (char *) "self",(char *) "r", NULL
52562 };
52563
52564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52566 if (!SWIG_IsOK(res1)) {
52567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52568 }
52569 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52570 ecode2 = SWIG_AsVal_int(obj1, &val2);
52571 if (!SWIG_IsOK(ecode2)) {
52572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52573 }
52574 arg2 = static_cast< wxRelationship >(val2);
52575 {
52576 PyThreadState* __tstate = wxPyBeginAllowThreads();
52577 (arg1)->SetRelationship(arg2);
52578 wxPyEndAllowThreads(__tstate);
52579 if (PyErr_Occurred()) SWIG_fail;
52580 }
52581 resultobj = SWIG_Py_Void();
52582 return resultobj;
52583 fail:
52584 return NULL;
52585 }
52586
52587
52588 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52589 PyObject *resultobj = 0;
52590 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52591 wxWindow *arg2 = (wxWindow *) 0 ;
52592 bool result;
52593 void *argp1 = 0 ;
52594 int res1 = 0 ;
52595 void *argp2 = 0 ;
52596 int res2 = 0 ;
52597 PyObject * obj0 = 0 ;
52598 PyObject * obj1 = 0 ;
52599 char * kwnames[] = {
52600 (char *) "self",(char *) "otherW", NULL
52601 };
52602
52603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52605 if (!SWIG_IsOK(res1)) {
52606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52607 }
52608 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52610 if (!SWIG_IsOK(res2)) {
52611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52612 }
52613 arg2 = reinterpret_cast< wxWindow * >(argp2);
52614 {
52615 PyThreadState* __tstate = wxPyBeginAllowThreads();
52616 result = (bool)(arg1)->ResetIfWin(arg2);
52617 wxPyEndAllowThreads(__tstate);
52618 if (PyErr_Occurred()) SWIG_fail;
52619 }
52620 {
52621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52622 }
52623 return resultobj;
52624 fail:
52625 return NULL;
52626 }
52627
52628
52629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52630 PyObject *resultobj = 0;
52631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52632 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52633 wxWindow *arg3 = (wxWindow *) 0 ;
52634 bool result;
52635 void *argp1 = 0 ;
52636 int res1 = 0 ;
52637 void *argp2 = 0 ;
52638 int res2 = 0 ;
52639 void *argp3 = 0 ;
52640 int res3 = 0 ;
52641 PyObject * obj0 = 0 ;
52642 PyObject * obj1 = 0 ;
52643 PyObject * obj2 = 0 ;
52644 char * kwnames[] = {
52645 (char *) "self",(char *) "constraints",(char *) "win", NULL
52646 };
52647
52648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52650 if (!SWIG_IsOK(res1)) {
52651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52652 }
52653 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52655 if (!SWIG_IsOK(res2)) {
52656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52657 }
52658 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52659 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52660 if (!SWIG_IsOK(res3)) {
52661 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52662 }
52663 arg3 = reinterpret_cast< wxWindow * >(argp3);
52664 {
52665 PyThreadState* __tstate = wxPyBeginAllowThreads();
52666 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52667 wxPyEndAllowThreads(__tstate);
52668 if (PyErr_Occurred()) SWIG_fail;
52669 }
52670 {
52671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52672 }
52673 return resultobj;
52674 fail:
52675 return NULL;
52676 }
52677
52678
52679 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52680 PyObject *resultobj = 0;
52681 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52682 wxEdge arg2 ;
52683 wxWindow *arg3 = (wxWindow *) 0 ;
52684 wxWindow *arg4 = (wxWindow *) 0 ;
52685 int result;
52686 void *argp1 = 0 ;
52687 int res1 = 0 ;
52688 int val2 ;
52689 int ecode2 = 0 ;
52690 void *argp3 = 0 ;
52691 int res3 = 0 ;
52692 void *argp4 = 0 ;
52693 int res4 = 0 ;
52694 PyObject * obj0 = 0 ;
52695 PyObject * obj1 = 0 ;
52696 PyObject * obj2 = 0 ;
52697 PyObject * obj3 = 0 ;
52698 char * kwnames[] = {
52699 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52700 };
52701
52702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52704 if (!SWIG_IsOK(res1)) {
52705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52706 }
52707 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52708 ecode2 = SWIG_AsVal_int(obj1, &val2);
52709 if (!SWIG_IsOK(ecode2)) {
52710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52711 }
52712 arg2 = static_cast< wxEdge >(val2);
52713 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52714 if (!SWIG_IsOK(res3)) {
52715 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52716 }
52717 arg3 = reinterpret_cast< wxWindow * >(argp3);
52718 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52719 if (!SWIG_IsOK(res4)) {
52720 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52721 }
52722 arg4 = reinterpret_cast< wxWindow * >(argp4);
52723 {
52724 PyThreadState* __tstate = wxPyBeginAllowThreads();
52725 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52726 wxPyEndAllowThreads(__tstate);
52727 if (PyErr_Occurred()) SWIG_fail;
52728 }
52729 resultobj = SWIG_From_int(static_cast< int >(result));
52730 return resultobj;
52731 fail:
52732 return NULL;
52733 }
52734
52735
52736 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52737 PyObject *obj;
52738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52739 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52740 return SWIG_Py_Void();
52741 }
52742
52743 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52744 PyObject *resultobj = 0;
52745 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52746 wxIndividualLayoutConstraint *result = 0 ;
52747 void *argp1 = 0 ;
52748 int res1 = 0 ;
52749 PyObject *swig_obj[1] ;
52750
52751 if (!args) SWIG_fail;
52752 swig_obj[0] = args;
52753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52754 if (!SWIG_IsOK(res1)) {
52755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52756 }
52757 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52758 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52760 return resultobj;
52761 fail:
52762 return NULL;
52763 }
52764
52765
52766 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52767 PyObject *resultobj = 0;
52768 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52769 wxIndividualLayoutConstraint *result = 0 ;
52770 void *argp1 = 0 ;
52771 int res1 = 0 ;
52772 PyObject *swig_obj[1] ;
52773
52774 if (!args) SWIG_fail;
52775 swig_obj[0] = args;
52776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52777 if (!SWIG_IsOK(res1)) {
52778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52779 }
52780 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52781 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52783 return resultobj;
52784 fail:
52785 return NULL;
52786 }
52787
52788
52789 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52790 PyObject *resultobj = 0;
52791 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52792 wxIndividualLayoutConstraint *result = 0 ;
52793 void *argp1 = 0 ;
52794 int res1 = 0 ;
52795 PyObject *swig_obj[1] ;
52796
52797 if (!args) SWIG_fail;
52798 swig_obj[0] = args;
52799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52800 if (!SWIG_IsOK(res1)) {
52801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52802 }
52803 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52804 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52806 return resultobj;
52807 fail:
52808 return NULL;
52809 }
52810
52811
52812 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52813 PyObject *resultobj = 0;
52814 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52815 wxIndividualLayoutConstraint *result = 0 ;
52816 void *argp1 = 0 ;
52817 int res1 = 0 ;
52818 PyObject *swig_obj[1] ;
52819
52820 if (!args) SWIG_fail;
52821 swig_obj[0] = args;
52822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52823 if (!SWIG_IsOK(res1)) {
52824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52825 }
52826 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52827 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52829 return resultobj;
52830 fail:
52831 return NULL;
52832 }
52833
52834
52835 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52836 PyObject *resultobj = 0;
52837 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52838 wxIndividualLayoutConstraint *result = 0 ;
52839 void *argp1 = 0 ;
52840 int res1 = 0 ;
52841 PyObject *swig_obj[1] ;
52842
52843 if (!args) SWIG_fail;
52844 swig_obj[0] = args;
52845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52846 if (!SWIG_IsOK(res1)) {
52847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52848 }
52849 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52850 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52852 return resultobj;
52853 fail:
52854 return NULL;
52855 }
52856
52857
52858 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52859 PyObject *resultobj = 0;
52860 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52861 wxIndividualLayoutConstraint *result = 0 ;
52862 void *argp1 = 0 ;
52863 int res1 = 0 ;
52864 PyObject *swig_obj[1] ;
52865
52866 if (!args) SWIG_fail;
52867 swig_obj[0] = args;
52868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52869 if (!SWIG_IsOK(res1)) {
52870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52871 }
52872 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52873 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52875 return resultobj;
52876 fail:
52877 return NULL;
52878 }
52879
52880
52881 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52882 PyObject *resultobj = 0;
52883 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52884 wxIndividualLayoutConstraint *result = 0 ;
52885 void *argp1 = 0 ;
52886 int res1 = 0 ;
52887 PyObject *swig_obj[1] ;
52888
52889 if (!args) SWIG_fail;
52890 swig_obj[0] = args;
52891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52892 if (!SWIG_IsOK(res1)) {
52893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52894 }
52895 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52896 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52898 return resultobj;
52899 fail:
52900 return NULL;
52901 }
52902
52903
52904 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52905 PyObject *resultobj = 0;
52906 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52907 wxIndividualLayoutConstraint *result = 0 ;
52908 void *argp1 = 0 ;
52909 int res1 = 0 ;
52910 PyObject *swig_obj[1] ;
52911
52912 if (!args) SWIG_fail;
52913 swig_obj[0] = args;
52914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52915 if (!SWIG_IsOK(res1)) {
52916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52917 }
52918 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52919 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52921 return resultobj;
52922 fail:
52923 return NULL;
52924 }
52925
52926
52927 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52928 PyObject *resultobj = 0;
52929 wxLayoutConstraints *result = 0 ;
52930
52931 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52932 {
52933 PyThreadState* __tstate = wxPyBeginAllowThreads();
52934 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52935 wxPyEndAllowThreads(__tstate);
52936 if (PyErr_Occurred()) SWIG_fail;
52937 }
52938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52939 return resultobj;
52940 fail:
52941 return NULL;
52942 }
52943
52944
52945 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52946 PyObject *resultobj = 0;
52947 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52948 void *argp1 = 0 ;
52949 int res1 = 0 ;
52950 PyObject *swig_obj[1] ;
52951
52952 if (!args) SWIG_fail;
52953 swig_obj[0] = args;
52954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52955 if (!SWIG_IsOK(res1)) {
52956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52957 }
52958 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52959 {
52960 PyThreadState* __tstate = wxPyBeginAllowThreads();
52961 delete arg1;
52962
52963 wxPyEndAllowThreads(__tstate);
52964 if (PyErr_Occurred()) SWIG_fail;
52965 }
52966 resultobj = SWIG_Py_Void();
52967 return resultobj;
52968 fail:
52969 return NULL;
52970 }
52971
52972
52973 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52974 PyObject *resultobj = 0;
52975 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52976 wxWindow *arg2 = (wxWindow *) 0 ;
52977 int *arg3 = (int *) 0 ;
52978 bool result;
52979 void *argp1 = 0 ;
52980 int res1 = 0 ;
52981 void *argp2 = 0 ;
52982 int res2 = 0 ;
52983 int temp3 ;
52984 int res3 = SWIG_TMPOBJ ;
52985 PyObject * obj0 = 0 ;
52986 PyObject * obj1 = 0 ;
52987 char * kwnames[] = {
52988 (char *) "self",(char *) "win", NULL
52989 };
52990
52991 arg3 = &temp3;
52992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52994 if (!SWIG_IsOK(res1)) {
52995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52996 }
52997 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52999 if (!SWIG_IsOK(res2)) {
53000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53001 }
53002 arg2 = reinterpret_cast< wxWindow * >(argp2);
53003 {
53004 PyThreadState* __tstate = wxPyBeginAllowThreads();
53005 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53006 wxPyEndAllowThreads(__tstate);
53007 if (PyErr_Occurred()) SWIG_fail;
53008 }
53009 {
53010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53011 }
53012 if (SWIG_IsTmpObj(res3)) {
53013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53014 } else {
53015 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53017 }
53018 return resultobj;
53019 fail:
53020 return NULL;
53021 }
53022
53023
53024 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53025 PyObject *resultobj = 0;
53026 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53027 bool result;
53028 void *argp1 = 0 ;
53029 int res1 = 0 ;
53030 PyObject *swig_obj[1] ;
53031
53032 if (!args) SWIG_fail;
53033 swig_obj[0] = args;
53034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53035 if (!SWIG_IsOK(res1)) {
53036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53037 }
53038 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53039 {
53040 PyThreadState* __tstate = wxPyBeginAllowThreads();
53041 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53042 wxPyEndAllowThreads(__tstate);
53043 if (PyErr_Occurred()) SWIG_fail;
53044 }
53045 {
53046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53047 }
53048 return resultobj;
53049 fail:
53050 return NULL;
53051 }
53052
53053
53054 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53055 PyObject *obj;
53056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53057 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53058 return SWIG_Py_Void();
53059 }
53060
53061 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53062 return SWIG_Python_InitShadowInstance(args);
53063 }
53064
53065 static PyMethodDef SwigMethods[] = {
53066 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53067 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53068 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53069 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53070 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53071 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53072 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53073 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53074 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53076 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53087 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53088 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53089 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53091 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53092 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53093 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53094 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53095 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53096 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53097 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53099 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53105 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53106 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53107 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53108 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53109 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53110 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53111 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53113 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53121 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53122 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53123 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53128 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53129 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53131 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53133 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53135 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53137 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53139 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53141 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53142 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53144 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53146 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53147 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53148 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53149 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53169 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53170 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53171 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53172 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53173 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53174 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53175 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53176 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53178 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53179 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53180 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53185 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53186 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53187 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53188 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53195 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53202 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53203 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53204 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53205 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53207 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53208 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53209 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53211 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53212 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53213 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53214 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53219 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53220 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53221 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53222 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53223 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53224 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53227 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53228 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53229 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53231 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53232 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53234 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53235 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53236 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53237 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53238 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53239 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53240 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53241 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53242 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53243 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53244 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53249 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53255 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53256 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53257 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53258 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53260 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53263 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53265 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53268 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53269 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53270 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53273 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53274 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53275 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53279 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53280 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53281 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53285 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53290 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53291 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53292 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53293 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53294 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53295 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53296 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53303 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53304 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53306 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53307 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53308 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53314 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53315 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53317 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53318 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53319 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53320 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53321 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53322 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53323 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53324 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53326 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53327 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53328 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53329 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53330 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53331 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53332 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53333 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53335 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53344 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53356 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53357 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53372 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53373 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53374 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53375 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53378 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53380 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53382 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53384 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53386 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53389 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53390 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53391 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53392 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53394 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53411 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53412 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53418 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53419 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53421 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53422 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53423 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53424 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53425 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53426 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53427 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53428 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53430 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53431 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53432 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53433 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53434 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53435 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53436 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53437 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53438 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53439 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53440 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53441 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53442 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53443 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53444 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53445 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53446 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53447 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53448 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53449 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53450 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53451 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53452 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53453 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53455 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53456 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53457 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53458 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53461 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53465 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53469 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53470 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53471 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53472 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53474 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53475 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53477 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53479 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53481 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53483 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53484 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53485 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53487 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53488 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53490 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53491 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53492 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53494 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53495 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53496 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53498 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53500 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53501 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53502 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53504 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53506 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53507 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53509 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53510 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53511 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53513 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53514 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53515 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53516 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53517 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53519 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53520 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53523 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53524 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53526 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53527 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53530 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53531 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53533 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53539 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53540 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53541 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53542 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53543 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53544 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53545 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53546 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53547 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53548 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53549 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53550 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53551 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53552 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53553 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53554 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53555 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53556 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53557 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53558 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53559 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53560 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53561 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53562 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53564 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53565 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53566 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53567 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53568 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53569 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53570 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53571 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53572 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53573 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53574 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53575 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53576 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53577 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53578 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53579 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53580 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53581 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53582 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53583 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53584 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53585 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53586 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53587 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53588 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53589 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53590 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53591 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53592 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53593 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53594 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53595 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53597 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53598 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53600 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53601 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53602 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53603 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53605 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53606 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53607 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53608 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53609 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53610 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53611 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53612 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53613 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53615 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53616 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53617 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53618 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53619 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53620 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53621 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53622 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53623 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53624 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53625 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53626 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53627 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53628 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53629 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53630 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53631 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53632 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53633 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53634 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53635 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53636 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53637 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53638 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53639 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53640 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53641 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53642 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53644 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53645 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53648 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53649 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53650 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53651 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53652 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53653 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53655 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53656 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53659 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53662 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53663 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53665 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53666 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53668 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53669 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53670 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53672 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53674 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53675 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53677 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53678 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53679 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53681 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53682 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53683 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53685 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53686 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53688 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53689 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53690 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53691 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53692 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53695 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53697 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53699 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53700 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53701 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53704 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53705 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53706 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53708 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53709 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53710 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53712 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53713 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53714 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53715 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53716 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53717 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53719 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53720 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53721 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53722 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53723 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53724 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53725 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53726 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53732 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53734 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53736 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53737 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53738 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53739 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53740 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53741 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53743 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53744 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53745 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53747 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53748 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53749 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53750 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53751 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53754 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53755 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53756 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53759 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53760 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53761 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53762 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53763 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53765 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53767 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53770 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53772 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53773 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53775 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53776 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53777 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53779 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53780 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53781 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53783 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53785 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53786 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53787 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53789 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53791 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53793 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53794 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53796 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53797 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53799 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53801 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53802 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53803 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53805 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53807 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53808 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53809 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53811 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53813 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53814 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53815 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53816 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53818 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53820 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53822 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53824 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53825 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53827 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53828 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53829 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53830 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53831 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53832 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53833 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53834 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53836 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53838 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53840 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53842 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53844 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53846 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53847 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53848 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53849 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53850 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53851 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53857 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53858 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53859 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53860 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53861 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53862 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53863 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53864 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53866 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53868 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53869 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53871 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53872 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53873 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53874 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53876 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53877 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53878 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53879 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53881 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53882 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53884 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53885 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53886 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53888 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53890 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53891 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53892 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53893 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53894 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53896 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53897 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53898 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53899 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53901 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53902 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53903 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53904 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53905 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53906 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53907 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53908 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53909 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53910 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53912 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53915 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53916 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53917 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53919 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53921 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53923 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53925 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53926 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53936 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53937 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53941 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53942 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53943 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53944 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53945 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53946 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53947 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53948 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53949 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53950 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53951 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53952 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53953 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53954 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53955 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53957 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53958 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53961 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53962 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53967 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53968 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53971 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53972 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53973 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53974 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53977 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53978 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53979 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53981 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53983 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53984 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53985 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53987 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53989 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53991 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53994 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53995 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53996 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53997 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53998 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53999 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54003 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54004 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54005 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54006 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54013 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54019 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54020 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54021 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54022 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54023 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54025 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54035 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54036 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54037 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54038 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54041 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54042 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54043 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54044 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54046 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54047 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54051 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54057 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54058 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54059 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54060 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54062 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54063 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54065 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54068 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54070 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54071 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54072 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54081 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54085 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54086 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54088 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54099 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54100 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54101 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54102 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54106 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54109 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54111 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54114 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54116 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54117 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54120 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54122 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54123 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54124 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54125 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54127 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54128 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54133 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54134 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54135 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54137 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54138 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54139 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54141 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54143 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54144 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54145 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54147 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54148 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54151 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54159 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54166 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54174 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54177 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54178 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54191 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54193 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54195 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54196 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54198 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54200 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54201 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54203 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54204 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54205 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54209 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54228 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54229 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54231 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54232 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54234 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54235 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54236 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54238 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54239 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54242 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54243 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54245 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54246 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54248 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54251 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54252 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54254 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54256 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54258 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54259 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54261 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54262 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54265 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54267 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54269 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54271 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54274 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54276 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54277 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54278 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54280 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54281 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54282 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54284 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54286 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54287 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54289 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54291 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54292 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54296 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54300 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54301 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54303 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54307 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54309 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54311 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54312 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54313 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54314 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54318 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54319 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54320 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54321 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54323 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54324 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54329 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54330 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54331 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54332 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54333 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54335 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54337 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54339 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54340 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54342 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54344 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54347 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54348 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54349 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54351 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54352 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54353 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54367 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54368 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54369 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54370 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54371 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54372 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54378 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54379 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54383 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54384 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54386 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54387 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54389 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54391 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54392 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54394 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54395 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54402 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54403 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54404 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54405 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54406 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54407 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54414 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54416 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54417 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54418 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54419 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54420 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54421 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54423 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54427 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54428 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54429 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54430 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54431 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54432 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54433 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54435 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54436 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54437 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54443 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54444 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54445 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54447 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54448 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54449 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54455 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54456 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54457 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54458 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54459 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54463 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54464 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54469 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54470 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54472 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54473 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54478 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54480 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54481 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54482 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54483 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54484 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54489 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54490 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54499 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54500 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54501 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54502 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54505 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54507 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54508 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54509 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54510 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54512 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54517 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54518 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54519 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54520 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54521 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54522 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54523 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54524 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54525 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54526 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54527 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54529 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54530 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54531 { NULL, NULL, 0, NULL }
54532 };
54533
54534
54535 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54536
54537 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54538 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54539 }
54540 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54541 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54542 }
54543 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54544 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54545 }
54546 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54547 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54548 }
54549 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54550 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54551 }
54552 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54553 return (void *)((wxSizer *) ((wxGridSizer *) x));
54554 }
54555 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54556 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54557 }
54558 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54559 return (void *)((wxSizer *) ((wxPySizer *) x));
54560 }
54561 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54562 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54563 }
54564 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54565 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54566 }
54567 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54568 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54569 }
54570 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54571 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54572 }
54573 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54574 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54575 }
54576 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54577 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54578 }
54579 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54580 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54581 }
54582 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54583 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54584 }
54585 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54586 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54587 }
54588 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54589 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54590 }
54591 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54592 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54593 }
54594 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54595 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54596 }
54597 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54598 return (void *)((wxEvent *) ((wxPyEvent *) x));
54599 }
54600 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54601 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54602 }
54603 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54604 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54605 }
54606 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54607 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54608 }
54609 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54610 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54611 }
54612 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54613 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54614 }
54615 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54616 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54617 }
54618 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54619 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54620 }
54621 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54622 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54623 }
54624 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54625 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54626 }
54627 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54628 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54629 }
54630 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54631 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54632 }
54633 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54634 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54635 }
54636 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54637 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54638 }
54639 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54640 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54641 }
54642 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54643 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54644 }
54645 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54646 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54647 }
54648 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54649 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54650 }
54651 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54652 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54653 }
54654 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54655 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54656 }
54657 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54658 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54659 }
54660 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54661 return (void *)((wxEvent *) ((wxShowEvent *) x));
54662 }
54663 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54664 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54665 }
54666 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54667 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54668 }
54669 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54670 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54671 }
54672 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54673 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54674 }
54675 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54676 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54677 }
54678 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54679 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54680 }
54681 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54682 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54683 }
54684 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54685 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54686 }
54687 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54688 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54689 }
54690 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54691 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54692 }
54693 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54694 return (void *)((wxControl *) ((wxControlWithItems *) x));
54695 }
54696 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54697 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54698 }
54699 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54700 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54701 }
54702 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54703 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54704 }
54705 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54706 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54707 }
54708 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54709 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54710 }
54711 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54712 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54713 }
54714 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54715 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54716 }
54717 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54718 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54719 }
54720 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54721 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54722 }
54723 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54724 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54725 }
54726 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54727 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54728 }
54729 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54730 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54731 }
54732 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54733 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54734 }
54735 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54736 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54737 }
54738 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54739 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54740 }
54741 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54742 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54743 }
54744 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54745 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54746 }
54747 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54748 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54749 }
54750 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54751 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54752 }
54753 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54754 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54755 }
54756 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54757 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54758 }
54759 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54760 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54761 }
54762 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54763 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54764 }
54765 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54766 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54767 }
54768 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54769 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54770 }
54771 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54772 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54773 }
54774 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54775 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54776 }
54777 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54778 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54779 }
54780 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54781 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54782 }
54783 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54784 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54785 }
54786 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54787 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54788 }
54789 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54790 return (void *)((wxObject *) ((wxSizerItem *) x));
54791 }
54792 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54793 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54794 }
54795 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54796 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54797 }
54798 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54799 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54800 }
54801 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54802 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54803 }
54804 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54805 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54806 }
54807 static void *_p_wxSizerTo_p_wxObject(void *x) {
54808 return (void *)((wxObject *) ((wxSizer *) x));
54809 }
54810 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54811 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54812 }
54813 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54814 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54815 }
54816 static void *_p_wxEventTo_p_wxObject(void *x) {
54817 return (void *)((wxObject *) ((wxEvent *) x));
54818 }
54819 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54820 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54821 }
54822 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54823 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54824 }
54825 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54826 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54827 }
54828 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54829 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54830 }
54831 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54832 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54833 }
54834 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54835 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54836 }
54837 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54838 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54839 }
54840 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54841 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54842 }
54843 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54844 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54845 }
54846 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54847 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54848 }
54849 static void *_p_wxControlTo_p_wxObject(void *x) {
54850 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54851 }
54852 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54853 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54854 }
54855 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54856 return (void *)((wxObject *) ((wxFSFile *) x));
54857 }
54858 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54859 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54860 }
54861 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54862 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54863 }
54864 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54865 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54866 }
54867 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54868 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54869 }
54870 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54871 return (void *)((wxObject *) ((wxMenuItem *) x));
54872 }
54873 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54874 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54875 }
54876 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54877 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54878 }
54879 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54880 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54881 }
54882 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54883 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54884 }
54885 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54886 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54887 }
54888 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54889 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54890 }
54891 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54892 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54893 }
54894 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54895 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54896 }
54897 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54898 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54899 }
54900 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54901 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54902 }
54903 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54904 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54905 }
54906 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54907 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54908 }
54909 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54910 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54911 }
54912 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54913 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54914 }
54915 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54916 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54917 }
54918 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54919 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54920 }
54921 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54922 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54923 }
54924 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54925 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54926 }
54927 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54928 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54929 }
54930 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54931 return (void *)((wxObject *) ((wxImageHandler *) x));
54932 }
54933 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54934 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54935 }
54936 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54937 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54938 }
54939 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54940 return (void *)((wxObject *) ((wxEvtHandler *) x));
54941 }
54942 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54943 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54944 }
54945 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54946 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54947 }
54948 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54949 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54950 }
54951 static void *_p_wxImageTo_p_wxObject(void *x) {
54952 return (void *)((wxObject *) ((wxImage *) x));
54953 }
54954 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54955 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54956 }
54957 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54958 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54959 }
54960 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54961 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54962 }
54963 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54964 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54965 }
54966 static void *_p_wxWindowTo_p_wxObject(void *x) {
54967 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54968 }
54969 static void *_p_wxMenuTo_p_wxObject(void *x) {
54970 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54971 }
54972 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54973 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54974 }
54975 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54976 return (void *)((wxObject *) ((wxFileSystem *) x));
54977 }
54978 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54979 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54980 }
54981 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54982 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54983 }
54984 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54985 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54986 }
54987 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54988 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54989 }
54990 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54991 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54992 }
54993 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54994 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54995 }
54996 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54997 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54998 }
54999 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55000 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55001 }
55002 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55003 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55004 }
55005 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55006 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55007 }
55008 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55009 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55010 }
55011 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55012 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55013 }
55014 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55015 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55016 }
55017 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55018 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55019 }
55020 static void *_p_wxControlTo_p_wxWindow(void *x) {
55021 return (void *)((wxWindow *) ((wxControl *) x));
55022 }
55023 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55024 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55025 }
55026 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55027 return (void *)((wxWindow *) ((wxMenuBar *) x));
55028 }
55029 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55030 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55031 }
55032 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55033 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55034 }
55035 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55036 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55037 }
55038 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55039 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55040 }
55041 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55042 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55043 }
55044 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55045 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55046 }
55047 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55048 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55049 }
55050 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55051 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55052 }
55053 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55054 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55055 }
55056 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55057 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55058 }
55059 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55060 return (void *)((wxValidator *) ((wxPyValidator *) x));
55061 }
55062 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55064 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};
55065 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55177 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55178 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55179 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55180 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55181 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55182 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55183 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55184 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55185 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55186 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55187 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55188 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55189 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55190 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55191 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55192 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55193 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55194
55195 static swig_type_info *swig_type_initial[] = {
55196 &_swigt__p_buffer,
55197 &_swigt__p_char,
55198 &_swigt__p_form_ops_t,
55199 &_swigt__p_int,
55200 &_swigt__p_long,
55201 &_swigt__p_unsigned_char,
55202 &_swigt__p_unsigned_int,
55203 &_swigt__p_unsigned_long,
55204 &_swigt__p_wxANIHandler,
55205 &_swigt__p_wxAcceleratorEntry,
55206 &_swigt__p_wxAcceleratorTable,
55207 &_swigt__p_wxActivateEvent,
55208 &_swigt__p_wxAppTraits,
55209 &_swigt__p_wxArrayString,
55210 &_swigt__p_wxBMPHandler,
55211 &_swigt__p_wxBitmap,
55212 &_swigt__p_wxBoxSizer,
55213 &_swigt__p_wxButton,
55214 &_swigt__p_wxCURHandler,
55215 &_swigt__p_wxCaret,
55216 &_swigt__p_wxChildFocusEvent,
55217 &_swigt__p_wxClipboardTextEvent,
55218 &_swigt__p_wxCloseEvent,
55219 &_swigt__p_wxColour,
55220 &_swigt__p_wxCommandEvent,
55221 &_swigt__p_wxContextMenuEvent,
55222 &_swigt__p_wxControl,
55223 &_swigt__p_wxControlWithItems,
55224 &_swigt__p_wxCursor,
55225 &_swigt__p_wxDC,
55226 &_swigt__p_wxDateEvent,
55227 &_swigt__p_wxDateTime,
55228 &_swigt__p_wxDisplayChangedEvent,
55229 &_swigt__p_wxDropFilesEvent,
55230 &_swigt__p_wxDuplexMode,
55231 &_swigt__p_wxEraseEvent,
55232 &_swigt__p_wxEvent,
55233 &_swigt__p_wxEventLoop,
55234 &_swigt__p_wxEventLoopActivator,
55235 &_swigt__p_wxEvtHandler,
55236 &_swigt__p_wxFSFile,
55237 &_swigt__p_wxFileSystem,
55238 &_swigt__p_wxFileSystemHandler,
55239 &_swigt__p_wxFlexGridSizer,
55240 &_swigt__p_wxFocusEvent,
55241 &_swigt__p_wxFont,
55242 &_swigt__p_wxFrame,
55243 &_swigt__p_wxGBPosition,
55244 &_swigt__p_wxGBSizerItem,
55245 &_swigt__p_wxGBSpan,
55246 &_swigt__p_wxGIFHandler,
55247 &_swigt__p_wxGridBagSizer,
55248 &_swigt__p_wxGridSizer,
55249 &_swigt__p_wxHelpEvent__Origin,
55250 &_swigt__p_wxICOHandler,
55251 &_swigt__p_wxIconizeEvent,
55252 &_swigt__p_wxIdleEvent,
55253 &_swigt__p_wxImage,
55254 &_swigt__p_wxImageHandler,
55255 &_swigt__p_wxImageHistogram,
55256 &_swigt__p_wxImage_HSVValue,
55257 &_swigt__p_wxImage_RGBValue,
55258 &_swigt__p_wxIndividualLayoutConstraint,
55259 &_swigt__p_wxInitDialogEvent,
55260 &_swigt__p_wxInputStream,
55261 &_swigt__p_wxInternetFSHandler,
55262 &_swigt__p_wxItemContainer,
55263 &_swigt__p_wxJPEGHandler,
55264 &_swigt__p_wxKeyEvent,
55265 &_swigt__p_wxLayoutConstraints,
55266 &_swigt__p_wxMaximizeEvent,
55267 &_swigt__p_wxMemoryFSHandler,
55268 &_swigt__p_wxMenu,
55269 &_swigt__p_wxMenuBar,
55270 &_swigt__p_wxMenuBarBase,
55271 &_swigt__p_wxMenuEvent,
55272 &_swigt__p_wxMenuItem,
55273 &_swigt__p_wxMouseCaptureChangedEvent,
55274 &_swigt__p_wxMouseCaptureLostEvent,
55275 &_swigt__p_wxMouseEvent,
55276 &_swigt__p_wxMoveEvent,
55277 &_swigt__p_wxNavigationKeyEvent,
55278 &_swigt__p_wxNcPaintEvent,
55279 &_swigt__p_wxNotifyEvent,
55280 &_swigt__p_wxObject,
55281 &_swigt__p_wxOutputStream,
55282 &_swigt__p_wxPCXHandler,
55283 &_swigt__p_wxPNGHandler,
55284 &_swigt__p_wxPNMHandler,
55285 &_swigt__p_wxPaintEvent,
55286 &_swigt__p_wxPaletteChangedEvent,
55287 &_swigt__p_wxPaperSize,
55288 &_swigt__p_wxPoint,
55289 &_swigt__p_wxPoint2D,
55290 &_swigt__p_wxPropagateOnce,
55291 &_swigt__p_wxPropagationDisabler,
55292 &_swigt__p_wxPyApp,
55293 &_swigt__p_wxPyCommandEvent,
55294 &_swigt__p_wxPyDropTarget,
55295 &_swigt__p_wxPyEvent,
55296 &_swigt__p_wxPyFileSystemHandler,
55297 &_swigt__p_wxPyImageHandler,
55298 &_swigt__p_wxPyInputStream,
55299 &_swigt__p_wxPySizer,
55300 &_swigt__p_wxPyValidator,
55301 &_swigt__p_wxQuantize,
55302 &_swigt__p_wxQueryNewPaletteEvent,
55303 &_swigt__p_wxRealPoint,
55304 &_swigt__p_wxRect,
55305 &_swigt__p_wxRegion,
55306 &_swigt__p_wxScrollEvent,
55307 &_swigt__p_wxScrollWinEvent,
55308 &_swigt__p_wxSetCursorEvent,
55309 &_swigt__p_wxShowEvent,
55310 &_swigt__p_wxSize,
55311 &_swigt__p_wxSizeEvent,
55312 &_swigt__p_wxSizer,
55313 &_swigt__p_wxSizerItem,
55314 &_swigt__p_wxStaticBox,
55315 &_swigt__p_wxStaticBoxSizer,
55316 &_swigt__p_wxStdDialogButtonSizer,
55317 &_swigt__p_wxSysColourChangedEvent,
55318 &_swigt__p_wxTIFFHandler,
55319 &_swigt__p_wxToolTip,
55320 &_swigt__p_wxUpdateUIEvent,
55321 &_swigt__p_wxValidator,
55322 &_swigt__p_wxVisualAttributes,
55323 &_swigt__p_wxWindow,
55324 &_swigt__p_wxWindowCreateEvent,
55325 &_swigt__p_wxWindowDestroyEvent,
55326 &_swigt__p_wxXPMHandler,
55327 &_swigt__p_wxZipFSHandler,
55328 };
55329
55330 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55331 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55332 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55333 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55335 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55336 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55337 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55338 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55339 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55340 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55341 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55343 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55344 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}};
55345 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55346 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}};
55347 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55348 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}};
55349 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55354 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}};
55355 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55356 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}};
55357 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55358 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55361 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55362 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55363 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55364 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55365 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55366 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55367 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55369 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}};
55370 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55372 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}};
55373 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}};
55374 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55375 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55376 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55379 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55380 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55382 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}};
55383 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55384 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}};
55385 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55387 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55388 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}};
55389 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55396 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}};
55397 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_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_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55429 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55430 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55431 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55432 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55437 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55438 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55439 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55440 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55441 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55442 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55445 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55446 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}};
55447 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}};
55448 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55449 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55450 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55451 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55452 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55453 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55454 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55455 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}};
55456 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55457 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}};
55458 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55459 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55460 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55461 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55462
55463 static swig_cast_info *swig_cast_initial[] = {
55464 _swigc__p_buffer,
55465 _swigc__p_char,
55466 _swigc__p_form_ops_t,
55467 _swigc__p_int,
55468 _swigc__p_long,
55469 _swigc__p_unsigned_char,
55470 _swigc__p_unsigned_int,
55471 _swigc__p_unsigned_long,
55472 _swigc__p_wxANIHandler,
55473 _swigc__p_wxAcceleratorEntry,
55474 _swigc__p_wxAcceleratorTable,
55475 _swigc__p_wxActivateEvent,
55476 _swigc__p_wxAppTraits,
55477 _swigc__p_wxArrayString,
55478 _swigc__p_wxBMPHandler,
55479 _swigc__p_wxBitmap,
55480 _swigc__p_wxBoxSizer,
55481 _swigc__p_wxButton,
55482 _swigc__p_wxCURHandler,
55483 _swigc__p_wxCaret,
55484 _swigc__p_wxChildFocusEvent,
55485 _swigc__p_wxClipboardTextEvent,
55486 _swigc__p_wxCloseEvent,
55487 _swigc__p_wxColour,
55488 _swigc__p_wxCommandEvent,
55489 _swigc__p_wxContextMenuEvent,
55490 _swigc__p_wxControl,
55491 _swigc__p_wxControlWithItems,
55492 _swigc__p_wxCursor,
55493 _swigc__p_wxDC,
55494 _swigc__p_wxDateEvent,
55495 _swigc__p_wxDateTime,
55496 _swigc__p_wxDisplayChangedEvent,
55497 _swigc__p_wxDropFilesEvent,
55498 _swigc__p_wxDuplexMode,
55499 _swigc__p_wxEraseEvent,
55500 _swigc__p_wxEvent,
55501 _swigc__p_wxEventLoop,
55502 _swigc__p_wxEventLoopActivator,
55503 _swigc__p_wxEvtHandler,
55504 _swigc__p_wxFSFile,
55505 _swigc__p_wxFileSystem,
55506 _swigc__p_wxFileSystemHandler,
55507 _swigc__p_wxFlexGridSizer,
55508 _swigc__p_wxFocusEvent,
55509 _swigc__p_wxFont,
55510 _swigc__p_wxFrame,
55511 _swigc__p_wxGBPosition,
55512 _swigc__p_wxGBSizerItem,
55513 _swigc__p_wxGBSpan,
55514 _swigc__p_wxGIFHandler,
55515 _swigc__p_wxGridBagSizer,
55516 _swigc__p_wxGridSizer,
55517 _swigc__p_wxHelpEvent__Origin,
55518 _swigc__p_wxICOHandler,
55519 _swigc__p_wxIconizeEvent,
55520 _swigc__p_wxIdleEvent,
55521 _swigc__p_wxImage,
55522 _swigc__p_wxImageHandler,
55523 _swigc__p_wxImageHistogram,
55524 _swigc__p_wxImage_HSVValue,
55525 _swigc__p_wxImage_RGBValue,
55526 _swigc__p_wxIndividualLayoutConstraint,
55527 _swigc__p_wxInitDialogEvent,
55528 _swigc__p_wxInputStream,
55529 _swigc__p_wxInternetFSHandler,
55530 _swigc__p_wxItemContainer,
55531 _swigc__p_wxJPEGHandler,
55532 _swigc__p_wxKeyEvent,
55533 _swigc__p_wxLayoutConstraints,
55534 _swigc__p_wxMaximizeEvent,
55535 _swigc__p_wxMemoryFSHandler,
55536 _swigc__p_wxMenu,
55537 _swigc__p_wxMenuBar,
55538 _swigc__p_wxMenuBarBase,
55539 _swigc__p_wxMenuEvent,
55540 _swigc__p_wxMenuItem,
55541 _swigc__p_wxMouseCaptureChangedEvent,
55542 _swigc__p_wxMouseCaptureLostEvent,
55543 _swigc__p_wxMouseEvent,
55544 _swigc__p_wxMoveEvent,
55545 _swigc__p_wxNavigationKeyEvent,
55546 _swigc__p_wxNcPaintEvent,
55547 _swigc__p_wxNotifyEvent,
55548 _swigc__p_wxObject,
55549 _swigc__p_wxOutputStream,
55550 _swigc__p_wxPCXHandler,
55551 _swigc__p_wxPNGHandler,
55552 _swigc__p_wxPNMHandler,
55553 _swigc__p_wxPaintEvent,
55554 _swigc__p_wxPaletteChangedEvent,
55555 _swigc__p_wxPaperSize,
55556 _swigc__p_wxPoint,
55557 _swigc__p_wxPoint2D,
55558 _swigc__p_wxPropagateOnce,
55559 _swigc__p_wxPropagationDisabler,
55560 _swigc__p_wxPyApp,
55561 _swigc__p_wxPyCommandEvent,
55562 _swigc__p_wxPyDropTarget,
55563 _swigc__p_wxPyEvent,
55564 _swigc__p_wxPyFileSystemHandler,
55565 _swigc__p_wxPyImageHandler,
55566 _swigc__p_wxPyInputStream,
55567 _swigc__p_wxPySizer,
55568 _swigc__p_wxPyValidator,
55569 _swigc__p_wxQuantize,
55570 _swigc__p_wxQueryNewPaletteEvent,
55571 _swigc__p_wxRealPoint,
55572 _swigc__p_wxRect,
55573 _swigc__p_wxRegion,
55574 _swigc__p_wxScrollEvent,
55575 _swigc__p_wxScrollWinEvent,
55576 _swigc__p_wxSetCursorEvent,
55577 _swigc__p_wxShowEvent,
55578 _swigc__p_wxSize,
55579 _swigc__p_wxSizeEvent,
55580 _swigc__p_wxSizer,
55581 _swigc__p_wxSizerItem,
55582 _swigc__p_wxStaticBox,
55583 _swigc__p_wxStaticBoxSizer,
55584 _swigc__p_wxStdDialogButtonSizer,
55585 _swigc__p_wxSysColourChangedEvent,
55586 _swigc__p_wxTIFFHandler,
55587 _swigc__p_wxToolTip,
55588 _swigc__p_wxUpdateUIEvent,
55589 _swigc__p_wxValidator,
55590 _swigc__p_wxVisualAttributes,
55591 _swigc__p_wxWindow,
55592 _swigc__p_wxWindowCreateEvent,
55593 _swigc__p_wxWindowDestroyEvent,
55594 _swigc__p_wxXPMHandler,
55595 _swigc__p_wxZipFSHandler,
55596 };
55597
55598
55599 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55600
55601 static swig_const_info swig_const_table[] = {
55602 {0, 0, 0, 0.0, 0, 0}};
55603
55604 #ifdef __cplusplus
55605 }
55606 #endif
55607 /* -----------------------------------------------------------------------------
55608 * Type initialization:
55609 * This problem is tough by the requirement that no dynamic
55610 * memory is used. Also, since swig_type_info structures store pointers to
55611 * swig_cast_info structures and swig_cast_info structures store pointers back
55612 * to swig_type_info structures, we need some lookup code at initialization.
55613 * The idea is that swig generates all the structures that are needed.
55614 * The runtime then collects these partially filled structures.
55615 * The SWIG_InitializeModule function takes these initial arrays out of
55616 * swig_module, and does all the lookup, filling in the swig_module.types
55617 * array with the correct data and linking the correct swig_cast_info
55618 * structures together.
55619 *
55620 * The generated swig_type_info structures are assigned staticly to an initial
55621 * array. We just loop though that array, and handle each type individually.
55622 * First we lookup if this type has been already loaded, and if so, use the
55623 * loaded structure instead of the generated one. Then we have to fill in the
55624 * cast linked list. The cast data is initially stored in something like a
55625 * two-dimensional array. Each row corresponds to a type (there are the same
55626 * number of rows as there are in the swig_type_initial array). Each entry in
55627 * a column is one of the swig_cast_info structures for that type.
55628 * The cast_initial array is actually an array of arrays, because each row has
55629 * a variable number of columns. So to actually build the cast linked list,
55630 * we find the array of casts associated with the type, and loop through it
55631 * adding the casts to the list. The one last trick we need to do is making
55632 * sure the type pointer in the swig_cast_info struct is correct.
55633 *
55634 * First off, we lookup the cast->type name to see if it is already loaded.
55635 * There are three cases to handle:
55636 * 1) If the cast->type has already been loaded AND the type we are adding
55637 * casting info to has not been loaded (it is in this module), THEN we
55638 * replace the cast->type pointer with the type pointer that has already
55639 * been loaded.
55640 * 2) If BOTH types (the one we are adding casting info to, and the
55641 * cast->type) are loaded, THEN the cast info has already been loaded by
55642 * the previous module so we just ignore it.
55643 * 3) Finally, if cast->type has not already been loaded, then we add that
55644 * swig_cast_info to the linked list (because the cast->type) pointer will
55645 * be correct.
55646 * ----------------------------------------------------------------------------- */
55647
55648 #ifdef __cplusplus
55649 extern "C" {
55650 #if 0
55651 } /* c-mode */
55652 #endif
55653 #endif
55654
55655 #if 0
55656 #define SWIGRUNTIME_DEBUG
55657 #endif
55658
55659 SWIGRUNTIME void
55660 SWIG_InitializeModule(void *clientdata) {
55661 size_t i;
55662 swig_module_info *module_head;
55663 static int init_run = 0;
55664
55665 clientdata = clientdata;
55666
55667 if (init_run) return;
55668 init_run = 1;
55669
55670 /* Initialize the swig_module */
55671 swig_module.type_initial = swig_type_initial;
55672 swig_module.cast_initial = swig_cast_initial;
55673
55674 /* Try and load any already created modules */
55675 module_head = SWIG_GetModule(clientdata);
55676 if (module_head) {
55677 swig_module.next = module_head->next;
55678 module_head->next = &swig_module;
55679 } else {
55680 /* This is the first module loaded */
55681 swig_module.next = &swig_module;
55682 SWIG_SetModule(clientdata, &swig_module);
55683 }
55684
55685 /* Now work on filling in swig_module.types */
55686 #ifdef SWIGRUNTIME_DEBUG
55687 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55688 #endif
55689 for (i = 0; i < swig_module.size; ++i) {
55690 swig_type_info *type = 0;
55691 swig_type_info *ret;
55692 swig_cast_info *cast;
55693
55694 #ifdef SWIGRUNTIME_DEBUG
55695 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55696 #endif
55697
55698 /* if there is another module already loaded */
55699 if (swig_module.next != &swig_module) {
55700 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55701 }
55702 if (type) {
55703 /* Overwrite clientdata field */
55704 #ifdef SWIGRUNTIME_DEBUG
55705 printf("SWIG_InitializeModule: found type %s\n", type->name);
55706 #endif
55707 if (swig_module.type_initial[i]->clientdata) {
55708 type->clientdata = swig_module.type_initial[i]->clientdata;
55709 #ifdef SWIGRUNTIME_DEBUG
55710 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55711 #endif
55712 }
55713 } else {
55714 type = swig_module.type_initial[i];
55715 }
55716
55717 /* Insert casting types */
55718 cast = swig_module.cast_initial[i];
55719 while (cast->type) {
55720 /* Don't need to add information already in the list */
55721 ret = 0;
55722 #ifdef SWIGRUNTIME_DEBUG
55723 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55724 #endif
55725 if (swig_module.next != &swig_module) {
55726 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55727 #ifdef SWIGRUNTIME_DEBUG
55728 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55729 #endif
55730 }
55731 if (ret) {
55732 if (type == swig_module.type_initial[i]) {
55733 #ifdef SWIGRUNTIME_DEBUG
55734 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55735 #endif
55736 cast->type = ret;
55737 ret = 0;
55738 } else {
55739 /* Check for casting already in the list */
55740 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55741 #ifdef SWIGRUNTIME_DEBUG
55742 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55743 #endif
55744 if (!ocast) ret = 0;
55745 }
55746 }
55747
55748 if (!ret) {
55749 #ifdef SWIGRUNTIME_DEBUG
55750 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55751 #endif
55752 if (type->cast) {
55753 type->cast->prev = cast;
55754 cast->next = type->cast;
55755 }
55756 type->cast = cast;
55757 }
55758 cast++;
55759 }
55760 /* Set entry in modules->types array equal to the type */
55761 swig_module.types[i] = type;
55762 }
55763 swig_module.types[i] = 0;
55764
55765 #ifdef SWIGRUNTIME_DEBUG
55766 printf("**** SWIG_InitializeModule: Cast List ******\n");
55767 for (i = 0; i < swig_module.size; ++i) {
55768 int j = 0;
55769 swig_cast_info *cast = swig_module.cast_initial[i];
55770 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55771 while (cast->type) {
55772 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55773 cast++;
55774 ++j;
55775 }
55776 printf("---- Total casts: %d\n",j);
55777 }
55778 printf("**** SWIG_InitializeModule: Cast List ******\n");
55779 #endif
55780 }
55781
55782 /* This function will propagate the clientdata field of type to
55783 * any new swig_type_info structures that have been added into the list
55784 * of equivalent types. It is like calling
55785 * SWIG_TypeClientData(type, clientdata) a second time.
55786 */
55787 SWIGRUNTIME void
55788 SWIG_PropagateClientData(void) {
55789 size_t i;
55790 swig_cast_info *equiv;
55791 static int init_run = 0;
55792
55793 if (init_run) return;
55794 init_run = 1;
55795
55796 for (i = 0; i < swig_module.size; i++) {
55797 if (swig_module.types[i]->clientdata) {
55798 equiv = swig_module.types[i]->cast;
55799 while (equiv) {
55800 if (!equiv->converter) {
55801 if (equiv->type && !equiv->type->clientdata)
55802 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55803 }
55804 equiv = equiv->next;
55805 }
55806 }
55807 }
55808 }
55809
55810 #ifdef __cplusplus
55811 #if 0
55812 {
55813 /* c-mode */
55814 #endif
55815 }
55816 #endif
55817
55818
55819
55820 #ifdef __cplusplus
55821 extern "C" {
55822 #endif
55823
55824 /* Python-specific SWIG API */
55825 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55826 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55827 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55828
55829 /* -----------------------------------------------------------------------------
55830 * global variable support code.
55831 * ----------------------------------------------------------------------------- */
55832
55833 typedef struct swig_globalvar {
55834 char *name; /* Name of global variable */
55835 PyObject *(*get_attr)(void); /* Return the current value */
55836 int (*set_attr)(PyObject *); /* Set the value */
55837 struct swig_globalvar *next;
55838 } swig_globalvar;
55839
55840 typedef struct swig_varlinkobject {
55841 PyObject_HEAD
55842 swig_globalvar *vars;
55843 } swig_varlinkobject;
55844
55845 SWIGINTERN PyObject *
55846 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55847 return PyString_FromString("<Swig global variables>");
55848 }
55849
55850 SWIGINTERN PyObject *
55851 swig_varlink_str(swig_varlinkobject *v) {
55852 PyObject *str = PyString_FromString("(");
55853 swig_globalvar *var;
55854 for (var = v->vars; var; var=var->next) {
55855 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55856 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55857 }
55858 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55859 return str;
55860 }
55861
55862 SWIGINTERN int
55863 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55864 PyObject *str = swig_varlink_str(v);
55865 fprintf(fp,"Swig global variables ");
55866 fprintf(fp,"%s\n", PyString_AsString(str));
55867 Py_DECREF(str);
55868 return 0;
55869 }
55870
55871 SWIGINTERN void
55872 swig_varlink_dealloc(swig_varlinkobject *v) {
55873 swig_globalvar *var = v->vars;
55874 while (var) {
55875 swig_globalvar *n = var->next;
55876 free(var->name);
55877 free(var);
55878 var = n;
55879 }
55880 }
55881
55882 SWIGINTERN PyObject *
55883 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55884 PyObject *res = NULL;
55885 swig_globalvar *var = v->vars;
55886 while (var) {
55887 if (strcmp(var->name,n) == 0) {
55888 res = (*var->get_attr)();
55889 break;
55890 }
55891 var = var->next;
55892 }
55893 if (res == NULL && !PyErr_Occurred()) {
55894 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55895 }
55896 return res;
55897 }
55898
55899 SWIGINTERN int
55900 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55901 int res = 1;
55902 swig_globalvar *var = v->vars;
55903 while (var) {
55904 if (strcmp(var->name,n) == 0) {
55905 res = (*var->set_attr)(p);
55906 break;
55907 }
55908 var = var->next;
55909 }
55910 if (res == 1 && !PyErr_Occurred()) {
55911 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55912 }
55913 return res;
55914 }
55915
55916 SWIGINTERN PyTypeObject*
55917 swig_varlink_type(void) {
55918 static char varlink__doc__[] = "Swig var link object";
55919 static PyTypeObject varlink_type;
55920 static int type_init = 0;
55921 if (!type_init) {
55922 const PyTypeObject tmp
55923 = {
55924 PyObject_HEAD_INIT(NULL)
55925 0, /* Number of items in variable part (ob_size) */
55926 (char *)"swigvarlink", /* Type name (tp_name) */
55927 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55928 0, /* Itemsize (tp_itemsize) */
55929 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55930 (printfunc) swig_varlink_print, /* Print (tp_print) */
55931 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55932 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55933 0, /* tp_compare */
55934 (reprfunc) swig_varlink_repr, /* tp_repr */
55935 0, /* tp_as_number */
55936 0, /* tp_as_sequence */
55937 0, /* tp_as_mapping */
55938 0, /* tp_hash */
55939 0, /* tp_call */
55940 (reprfunc)swig_varlink_str, /* tp_str */
55941 0, /* tp_getattro */
55942 0, /* tp_setattro */
55943 0, /* tp_as_buffer */
55944 0, /* tp_flags */
55945 varlink__doc__, /* tp_doc */
55946 0, /* tp_traverse */
55947 0, /* tp_clear */
55948 0, /* tp_richcompare */
55949 0, /* tp_weaklistoffset */
55950 #if PY_VERSION_HEX >= 0x02020000
55951 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55952 #endif
55953 #if PY_VERSION_HEX >= 0x02030000
55954 0, /* tp_del */
55955 #endif
55956 #ifdef COUNT_ALLOCS
55957 0,0,0,0 /* tp_alloc -> tp_next */
55958 #endif
55959 };
55960 varlink_type = tmp;
55961 varlink_type.ob_type = &PyType_Type;
55962 type_init = 1;
55963 }
55964 return &varlink_type;
55965 }
55966
55967 /* Create a variable linking object for use later */
55968 SWIGINTERN PyObject *
55969 SWIG_Python_newvarlink(void) {
55970 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55971 if (result) {
55972 result->vars = 0;
55973 }
55974 return ((PyObject*) result);
55975 }
55976
55977 SWIGINTERN void
55978 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55979 swig_varlinkobject *v = (swig_varlinkobject *) p;
55980 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55981 if (gv) {
55982 size_t size = strlen(name)+1;
55983 gv->name = (char *)malloc(size);
55984 if (gv->name) {
55985 strncpy(gv->name,name,size);
55986 gv->get_attr = get_attr;
55987 gv->set_attr = set_attr;
55988 gv->next = v->vars;
55989 }
55990 }
55991 v->vars = gv;
55992 }
55993
55994 SWIGINTERN PyObject *
55995 SWIG_globals() {
55996 static PyObject *_SWIG_globals = 0;
55997 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55998 return _SWIG_globals;
55999 }
56000
56001 /* -----------------------------------------------------------------------------
56002 * constants/methods manipulation
56003 * ----------------------------------------------------------------------------- */
56004
56005 /* Install Constants */
56006 SWIGINTERN void
56007 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56008 PyObject *obj = 0;
56009 size_t i;
56010 for (i = 0; constants[i].type; ++i) {
56011 switch(constants[i].type) {
56012 case SWIG_PY_POINTER:
56013 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56014 break;
56015 case SWIG_PY_BINARY:
56016 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56017 break;
56018 default:
56019 obj = 0;
56020 break;
56021 }
56022 if (obj) {
56023 PyDict_SetItemString(d, constants[i].name, obj);
56024 Py_DECREF(obj);
56025 }
56026 }
56027 }
56028
56029 /* -----------------------------------------------------------------------------*/
56030 /* Fix SwigMethods to carry the callback ptrs when needed */
56031 /* -----------------------------------------------------------------------------*/
56032
56033 SWIGINTERN void
56034 SWIG_Python_FixMethods(PyMethodDef *methods,
56035 swig_const_info *const_table,
56036 swig_type_info **types,
56037 swig_type_info **types_initial) {
56038 size_t i;
56039 for (i = 0; methods[i].ml_name; ++i) {
56040 const char *c = methods[i].ml_doc;
56041 if (c && (c = strstr(c, "swig_ptr: "))) {
56042 int j;
56043 swig_const_info *ci = 0;
56044 const char *name = c + 10;
56045 for (j = 0; const_table[j].type; ++j) {
56046 if (strncmp(const_table[j].name, name,
56047 strlen(const_table[j].name)) == 0) {
56048 ci = &(const_table[j]);
56049 break;
56050 }
56051 }
56052 if (ci) {
56053 size_t shift = (ci->ptype) - types;
56054 swig_type_info *ty = types_initial[shift];
56055 size_t ldoc = (c - methods[i].ml_doc);
56056 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56057 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56058 if (ndoc) {
56059 char *buff = ndoc;
56060 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56061 if (ptr) {
56062 strncpy(buff, methods[i].ml_doc, ldoc);
56063 buff += ldoc;
56064 strncpy(buff, "swig_ptr: ", 10);
56065 buff += 10;
56066 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56067 methods[i].ml_doc = ndoc;
56068 }
56069 }
56070 }
56071 }
56072 }
56073 }
56074
56075 #ifdef __cplusplus
56076 }
56077 #endif
56078
56079 /* -----------------------------------------------------------------------------*
56080 * Partial Init method
56081 * -----------------------------------------------------------------------------*/
56082
56083 #ifdef __cplusplus
56084 extern "C"
56085 #endif
56086 SWIGEXPORT void SWIG_init(void) {
56087 PyObject *m, *d;
56088
56089 /* Fix SwigMethods to carry the callback ptrs when needed */
56090 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56091
56092 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56093 d = PyModule_GetDict(m);
56094
56095 SWIG_InitializeModule(0);
56096 SWIG_InstallConstants(d,swig_const_table);
56097
56098
56099
56100 #ifndef wxPyUSE_EXPORT
56101 // Make our API structure a CObject so other modules can import it
56102 // from this module.
56103 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56104 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56105 Py_XDECREF(cobj);
56106 #endif
56107
56108 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56109 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56110 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56111 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56112 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56113 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56114 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56115 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56116 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56117 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56118 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56119 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56120 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56121 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56122 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56123 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56124 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56125 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56126 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56127 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56128 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56129 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56130 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56131 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56132 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56133 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56134 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56135 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56136 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56137 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56138 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56139 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56140 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56141 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56142 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56143 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56144 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56145 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56146 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56147 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56148 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56149 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56150 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56151 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56152 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56153 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56154 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56155 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56156 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56157 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56158 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56159 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56160 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56161 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56162 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56163 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56164 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56165 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56166 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56167 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56168 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56169 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56170 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56171 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56172 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56173 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56174 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56175 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56176 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56177 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56178 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56179 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56180 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56181 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56182 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56183 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56184 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56185 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56186 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56187 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56188 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56189 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56190 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56191 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56192 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56193 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56194 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56195 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56196 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56197 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56198 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56199 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56200 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56201 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56202 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56203 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56204 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56205 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56206 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56207 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56208 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56209 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56210 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56211 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56212 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56213 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56214 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56215 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56216 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56217 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56218 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56219 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56220 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56221 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56222 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56223 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56224 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56225 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56226 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56227 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56228 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56229 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56230 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56231 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56232 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56233 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56234 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56235 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56236 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56237 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56238 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56239 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56240 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56241 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56242 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56243 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56244 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56245 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56246 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56247 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56248 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56249 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56250 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56251 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56252 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56253 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56254 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56255 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56256 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56257 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56258 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56259 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56260 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56261 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56262 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56263 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56264 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56265 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56266 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56267 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56268 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56269 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56270 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56271 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56272 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56273 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56274 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56275 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56276 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56277 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56278 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56279 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56280 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56281 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56282 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56283 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56284 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56285 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56286 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56287 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56288 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56289 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56290 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56291 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56292 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56293 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56294 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56295 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56296 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56297 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56298 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56299 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56300 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56301 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56302 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56303 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56304 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56305 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56306 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56307 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56308 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56309 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56310 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56311 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56312 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56313 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56314 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56315 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56316 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56317 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56318 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56319 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56320 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56321 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56322 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56323 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56324 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56325 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56326 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56327 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56328 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56329 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56330 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56331 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56332 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56333 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56334 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56335 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56336 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56337 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56338 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56339 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56340 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56341 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56342 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56343 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56344 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56345 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56346 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56347 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56348 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56349 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56350 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56351 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56352 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56353 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56354 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56355 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56356 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56357 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56358 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56359 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56360 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56361 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56362 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56363 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56364 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56365 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56366 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56367 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56368 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56369 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56370 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56371 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56372 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56373 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56374 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56375 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56376 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56377 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56378 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56379 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56380 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56381 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56382 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56383 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56384 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56385 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56386 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56387 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56388 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56389 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56390 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56391 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56392 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56393 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56394 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56395 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56396 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56397 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56398 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56399 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56400 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56401 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56402 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56403 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56404 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56405 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56406 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56407 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56408 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56409 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56410 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56411 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56412 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56413 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56414 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56415 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56416 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56417 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56418 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56419 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56420 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56421 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56422 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56423 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56424 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56425 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56426 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56427 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56428 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56429 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56430 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56431 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56432 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56433 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56434 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56435 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56436 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56437 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56438 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56439 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56440 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56441 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56442 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56443 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56444 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56445 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56446 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56447 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56448 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56449 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56450 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56451 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56452 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56453 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56454 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56455 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56456 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56457 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56458 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56459 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56460 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56461 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56462 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56463 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56464 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56465 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56466 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56467 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56468 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56469 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56470 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56471 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56472 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56473 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56474 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56475 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56476 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56477 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56478 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56479 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56480 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56481 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56482 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56483 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56484 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56485 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56486 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56487 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56488 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56489 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56490 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56491 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56492 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56493 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56494 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56495 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56496 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56497 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56498 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56499 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56500 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56501 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56502 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56503 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56505 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56506 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56507 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56508 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56509 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56510 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56511 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56512 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56513 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56514 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56515 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56516 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56517 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56518 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56519 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56520 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56521 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56522 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56523 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56524 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56525 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56526 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56527 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56528 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56529 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56530 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56531 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56532 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56533 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56534 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56535 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56536 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56537 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56538 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56539 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56540 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56541 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56542 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56543 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56544 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56545 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56546 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56547 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56548 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56549 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56550 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56551 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56552 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56553 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56554 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56555 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56556 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56557 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56558 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56559 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56560 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56561 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56562 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56563 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56564 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56565 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56566 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56567 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56568 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56569 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56570 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56571 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56572 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56573 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56574 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56575 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56576 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56577 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56578 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56579 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56580 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56581 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56582 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56583 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56584 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56585 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56586 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56587 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56588 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56589 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56590 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56591 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56592 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56593 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56594 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56595 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56596 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56597 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56598 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56599 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56600 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56601 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56602 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56603 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56604 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56605 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56606 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56607 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56608 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56609 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56610 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56611 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56612 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56613 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56614 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56615 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56616 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56617 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56618 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56619 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56620 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56621 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56622 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56623 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56624 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56625 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56626 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56627 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56628 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56629 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56630 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56631 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56632 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56633 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56634 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56635 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56636 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56637 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56638 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56639 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56640 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56641 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56642 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56643 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56644 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56645 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56646 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56647 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56648 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56649 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56650 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56651 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56652 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56653 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56654 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56655 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56656 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56657 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56658 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56659 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56660 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56661 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56662 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56663 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56664 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56665 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56666 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56667 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56668 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56669 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56670 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56671 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56672 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56673 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56674 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56675 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56676 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56677 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56678 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56679 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56680 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56681 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56682 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56683 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56684 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56685 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56686 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56687 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56688 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56689 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56690 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56691 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56692 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56693 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56694 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56695 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56696 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56697 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56698 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56699 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56700 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56701 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56702 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56703 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56704 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56705 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56706 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56707 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56708 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56709 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56710 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56711 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56712 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56713 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56714 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56715 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56716 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56717 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56718 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56719 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56720 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56721 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56722 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56723 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56724 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56725 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56726 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56727 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56728 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56729 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56730 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56731 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56732 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56733 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56734 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56735 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56736 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56737 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56738 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56739 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56740 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56741 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56742 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56743 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56744 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56745 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56746 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56747 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56748 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56749 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56750 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56751 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56752 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56753 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56754 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56755 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56756 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56757 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56758 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56759 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56760 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56761 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56762 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56763 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56764 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56765 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56766 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56767 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56768 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56769 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56770
56771 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56772
56773
56774 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56775
56776 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56777 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56778 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56779 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56780 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56781 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56782 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56783 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56784 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56785 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56786 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56787 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56788 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56789 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56790 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56791 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56792 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56793 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56794 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56795 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56796 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56797 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56798 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56799 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56800 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56801 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56802 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56803 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56804 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56805 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56806 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56807 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56808 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56809 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56810 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56811 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56812 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56813 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56814 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56815 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56816 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56817 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56818 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56819 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56820 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56821 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56822 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56823 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56824 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56825 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56826 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56827 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56828 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56829 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56830 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56831 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56832 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56833 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56834 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56835 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56836 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56837 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56838 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56839 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56840 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56841 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56842 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56843 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56844 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56845 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56846 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56847 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56848 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56849 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56850 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56851 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56852 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56853 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56854 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56855 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56856 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56857 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56858 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56859 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56860 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56861 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56862 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56863 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56864 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56865 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56866 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56867 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56868 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56869 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56870 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56871 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56872 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56873 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56874 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56875 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56876 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56877 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56878 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56879 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56880 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56881 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56882 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56883 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56884 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56885 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56886 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56887 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56888 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56889 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56890 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56891 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56892 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56893 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56894 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56895 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56896 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56897 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56898 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56899 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56900 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56901 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56902 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56903 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56904 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56905 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56906 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56907 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56908 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56909 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56910 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56911 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56912 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56913 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56914 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56915 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56916 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56917 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56918 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56919 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56920 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56921 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56922 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56923 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56924 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56925 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56926 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56927 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56928 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56929 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56930 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56931 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56932 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56933 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56934 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56935 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56936 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56937 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56938 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56939 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56940 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56941 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56942 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56943 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56944 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56945 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56946 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56947 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56948 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56949 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56950 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56951 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56952 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56953 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56954 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56955 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
56956 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56957 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56958 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56959 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56960 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56961 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56962 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56963 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56964 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56965 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56966 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56967 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56968 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56969 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56970 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56971 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56972 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56973 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56974 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56975 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56976 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56977 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56978 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56979 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56980 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56981 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56982 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56983 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56984 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56985 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56986 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56987 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56988
56989 // Initialize threading, some globals and such
56990 __wxPyPreStart(d);
56991
56992
56993 // Although these are defined in __version__ they need to be here too so
56994 // that an assert can be done to ensure that the wxPython and the wxWindows
56995 // versions match.
56996 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56997 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56998 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56999
57000 }
57001
wxWidgets (Impactor)