]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use PyObject_AsReadBuffer in the typemap for getting buffer or buffer
[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 (obj2 != Py_None) {
13418 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13419 }
13420 }
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13428 return resultobj;
13429 fail:
13430 return NULL;
13431 }
13432
13433
13434 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13435 PyObject *resultobj = 0;
13436 int arg1 ;
13437 int arg2 ;
13438 buffer arg3 ;
13439 int arg4 ;
13440 buffer arg5 ;
13441 int arg6 ;
13442 wxImage *result = 0 ;
13443 int val1 ;
13444 int ecode1 = 0 ;
13445 int val2 ;
13446 int ecode2 = 0 ;
13447 PyObject * obj0 = 0 ;
13448 PyObject * obj1 = 0 ;
13449 PyObject * obj2 = 0 ;
13450 PyObject * obj3 = 0 ;
13451 char * kwnames[] = {
13452 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13453 };
13454
13455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13456 ecode1 = SWIG_AsVal_int(obj0, &val1);
13457 if (!SWIG_IsOK(ecode1)) {
13458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13459 }
13460 arg1 = static_cast< int >(val1);
13461 ecode2 = SWIG_AsVal_int(obj1, &val2);
13462 if (!SWIG_IsOK(ecode2)) {
13463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13464 }
13465 arg2 = static_cast< int >(val2);
13466 {
13467 if (obj2 != Py_None) {
13468 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13469 }
13470 }
13471 {
13472 if (obj3 != Py_None) {
13473 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13474 }
13475 }
13476 {
13477 PyThreadState* __tstate = wxPyBeginAllowThreads();
13478 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13479 wxPyEndAllowThreads(__tstate);
13480 if (PyErr_Occurred()) SWIG_fail;
13481 }
13482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13483 return resultobj;
13484 fail:
13485 return NULL;
13486 }
13487
13488
13489 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13490 PyObject *resultobj = 0;
13491 wxImage *arg1 = (wxImage *) 0 ;
13492 int arg2 ;
13493 int arg3 ;
13494 bool arg4 = (bool) true ;
13495 void *argp1 = 0 ;
13496 int res1 = 0 ;
13497 int val2 ;
13498 int ecode2 = 0 ;
13499 int val3 ;
13500 int ecode3 = 0 ;
13501 bool val4 ;
13502 int ecode4 = 0 ;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 PyObject * obj2 = 0 ;
13506 PyObject * obj3 = 0 ;
13507 char * kwnames[] = {
13508 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13509 };
13510
13511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13513 if (!SWIG_IsOK(res1)) {
13514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13515 }
13516 arg1 = reinterpret_cast< wxImage * >(argp1);
13517 ecode2 = SWIG_AsVal_int(obj1, &val2);
13518 if (!SWIG_IsOK(ecode2)) {
13519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13520 }
13521 arg2 = static_cast< int >(val2);
13522 ecode3 = SWIG_AsVal_int(obj2, &val3);
13523 if (!SWIG_IsOK(ecode3)) {
13524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13525 }
13526 arg3 = static_cast< int >(val3);
13527 if (obj3) {
13528 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13529 if (!SWIG_IsOK(ecode4)) {
13530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13531 }
13532 arg4 = static_cast< bool >(val4);
13533 }
13534 {
13535 PyThreadState* __tstate = wxPyBeginAllowThreads();
13536 (arg1)->Create(arg2,arg3,arg4);
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 resultobj = SWIG_Py_Void();
13541 return resultobj;
13542 fail:
13543 return NULL;
13544 }
13545
13546
13547 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13548 PyObject *resultobj = 0;
13549 wxImage *arg1 = (wxImage *) 0 ;
13550 void *argp1 = 0 ;
13551 int res1 = 0 ;
13552 PyObject *swig_obj[1] ;
13553
13554 if (!args) SWIG_fail;
13555 swig_obj[0] = args;
13556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13557 if (!SWIG_IsOK(res1)) {
13558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13559 }
13560 arg1 = reinterpret_cast< wxImage * >(argp1);
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 (arg1)->Destroy();
13564 wxPyEndAllowThreads(__tstate);
13565 if (PyErr_Occurred()) SWIG_fail;
13566 }
13567 resultobj = SWIG_Py_Void();
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj = 0;
13576 wxImage *arg1 = (wxImage *) 0 ;
13577 int arg2 ;
13578 int arg3 ;
13579 SwigValueWrapper<wxImage > result;
13580 void *argp1 = 0 ;
13581 int res1 = 0 ;
13582 int val2 ;
13583 int ecode2 = 0 ;
13584 int val3 ;
13585 int ecode3 = 0 ;
13586 PyObject * obj0 = 0 ;
13587 PyObject * obj1 = 0 ;
13588 PyObject * obj2 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "self",(char *) "width",(char *) "height", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13595 if (!SWIG_IsOK(res1)) {
13596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13597 }
13598 arg1 = reinterpret_cast< wxImage * >(argp1);
13599 ecode2 = SWIG_AsVal_int(obj1, &val2);
13600 if (!SWIG_IsOK(ecode2)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13602 }
13603 arg2 = static_cast< int >(val2);
13604 ecode3 = SWIG_AsVal_int(obj2, &val3);
13605 if (!SWIG_IsOK(ecode3)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13607 }
13608 arg3 = static_cast< int >(val3);
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = (arg1)->Scale(arg2,arg3);
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 int arg2 ;
13626 int arg3 ;
13627 SwigValueWrapper<wxImage > result;
13628 void *argp1 = 0 ;
13629 int res1 = 0 ;
13630 int val2 ;
13631 int ecode2 = 0 ;
13632 int val3 ;
13633 int ecode3 = 0 ;
13634 PyObject * obj0 = 0 ;
13635 PyObject * obj1 = 0 ;
13636 PyObject * obj2 = 0 ;
13637 char * kwnames[] = {
13638 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13639 };
13640
13641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13643 if (!SWIG_IsOK(res1)) {
13644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13645 }
13646 arg1 = reinterpret_cast< wxImage * >(argp1);
13647 ecode2 = SWIG_AsVal_int(obj1, &val2);
13648 if (!SWIG_IsOK(ecode2)) {
13649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13650 }
13651 arg2 = static_cast< int >(val2);
13652 ecode3 = SWIG_AsVal_int(obj2, &val3);
13653 if (!SWIG_IsOK(ecode3)) {
13654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13655 }
13656 arg3 = static_cast< int >(val3);
13657 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13660 wxPyEndAllowThreads(__tstate);
13661 if (PyErr_Occurred()) SWIG_fail;
13662 }
13663 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13664 return resultobj;
13665 fail:
13666 return NULL;
13667 }
13668
13669
13670 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13671 PyObject *resultobj = 0;
13672 wxImage *arg1 = (wxImage *) 0 ;
13673 int arg2 ;
13674 int arg3 ;
13675 wxImage *result = 0 ;
13676 void *argp1 = 0 ;
13677 int res1 = 0 ;
13678 int val2 ;
13679 int ecode2 = 0 ;
13680 int val3 ;
13681 int ecode3 = 0 ;
13682 PyObject * obj0 = 0 ;
13683 PyObject * obj1 = 0 ;
13684 PyObject * obj2 = 0 ;
13685 char * kwnames[] = {
13686 (char *) "self",(char *) "width",(char *) "height", NULL
13687 };
13688
13689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13691 if (!SWIG_IsOK(res1)) {
13692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13693 }
13694 arg1 = reinterpret_cast< wxImage * >(argp1);
13695 ecode2 = SWIG_AsVal_int(obj1, &val2);
13696 if (!SWIG_IsOK(ecode2)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13698 }
13699 arg2 = static_cast< int >(val2);
13700 ecode3 = SWIG_AsVal_int(obj2, &val3);
13701 if (!SWIG_IsOK(ecode3)) {
13702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13703 }
13704 arg3 = static_cast< int >(val3);
13705 {
13706 PyThreadState* __tstate = wxPyBeginAllowThreads();
13707 {
13708 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13709 result = (wxImage *) &_result_ref;
13710 }
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj = 0;
13723 wxImage *arg1 = (wxImage *) 0 ;
13724 wxSize *arg2 = 0 ;
13725 wxPoint *arg3 = 0 ;
13726 int arg4 = (int) -1 ;
13727 int arg5 = (int) -1 ;
13728 int arg6 = (int) -1 ;
13729 wxImage *result = 0 ;
13730 void *argp1 = 0 ;
13731 int res1 = 0 ;
13732 wxSize temp2 ;
13733 wxPoint temp3 ;
13734 int val4 ;
13735 int ecode4 = 0 ;
13736 int val5 ;
13737 int ecode5 = 0 ;
13738 int val6 ;
13739 int ecode6 = 0 ;
13740 PyObject * obj0 = 0 ;
13741 PyObject * obj1 = 0 ;
13742 PyObject * obj2 = 0 ;
13743 PyObject * obj3 = 0 ;
13744 PyObject * obj4 = 0 ;
13745 PyObject * obj5 = 0 ;
13746 char * kwnames[] = {
13747 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13748 };
13749
13750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13752 if (!SWIG_IsOK(res1)) {
13753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13754 }
13755 arg1 = reinterpret_cast< wxImage * >(argp1);
13756 {
13757 arg2 = &temp2;
13758 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13759 }
13760 {
13761 arg3 = &temp3;
13762 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13763 }
13764 if (obj3) {
13765 ecode4 = SWIG_AsVal_int(obj3, &val4);
13766 if (!SWIG_IsOK(ecode4)) {
13767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13768 }
13769 arg4 = static_cast< int >(val4);
13770 }
13771 if (obj4) {
13772 ecode5 = SWIG_AsVal_int(obj4, &val5);
13773 if (!SWIG_IsOK(ecode5)) {
13774 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13775 }
13776 arg5 = static_cast< int >(val5);
13777 }
13778 if (obj5) {
13779 ecode6 = SWIG_AsVal_int(obj5, &val6);
13780 if (!SWIG_IsOK(ecode6)) {
13781 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13782 }
13783 arg6 = static_cast< int >(val6);
13784 }
13785 {
13786 PyThreadState* __tstate = wxPyBeginAllowThreads();
13787 {
13788 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13789 result = (wxImage *) &_result_ref;
13790 }
13791 wxPyEndAllowThreads(__tstate);
13792 if (PyErr_Occurred()) SWIG_fail;
13793 }
13794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13795 return resultobj;
13796 fail:
13797 return NULL;
13798 }
13799
13800
13801 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj = 0;
13803 wxImage *arg1 = (wxImage *) 0 ;
13804 int arg2 ;
13805 int arg3 ;
13806 byte arg4 ;
13807 byte arg5 ;
13808 byte arg6 ;
13809 void *argp1 = 0 ;
13810 int res1 = 0 ;
13811 int val2 ;
13812 int ecode2 = 0 ;
13813 int val3 ;
13814 int ecode3 = 0 ;
13815 unsigned char val4 ;
13816 int ecode4 = 0 ;
13817 unsigned char val5 ;
13818 int ecode5 = 0 ;
13819 unsigned char val6 ;
13820 int ecode6 = 0 ;
13821 PyObject * obj0 = 0 ;
13822 PyObject * obj1 = 0 ;
13823 PyObject * obj2 = 0 ;
13824 PyObject * obj3 = 0 ;
13825 PyObject * obj4 = 0 ;
13826 PyObject * obj5 = 0 ;
13827 char * kwnames[] = {
13828 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13829 };
13830
13831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13833 if (!SWIG_IsOK(res1)) {
13834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13835 }
13836 arg1 = reinterpret_cast< wxImage * >(argp1);
13837 ecode2 = SWIG_AsVal_int(obj1, &val2);
13838 if (!SWIG_IsOK(ecode2)) {
13839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13840 }
13841 arg2 = static_cast< int >(val2);
13842 ecode3 = SWIG_AsVal_int(obj2, &val3);
13843 if (!SWIG_IsOK(ecode3)) {
13844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13845 }
13846 arg3 = static_cast< int >(val3);
13847 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13848 if (!SWIG_IsOK(ecode4)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13850 }
13851 arg4 = static_cast< byte >(val4);
13852 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13853 if (!SWIG_IsOK(ecode5)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13855 }
13856 arg5 = static_cast< byte >(val5);
13857 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13858 if (!SWIG_IsOK(ecode6)) {
13859 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13860 }
13861 arg6 = static_cast< byte >(val6);
13862 {
13863 PyThreadState* __tstate = wxPyBeginAllowThreads();
13864 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13865 wxPyEndAllowThreads(__tstate);
13866 if (PyErr_Occurred()) SWIG_fail;
13867 }
13868 resultobj = SWIG_Py_Void();
13869 return resultobj;
13870 fail:
13871 return NULL;
13872 }
13873
13874
13875 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj = 0;
13877 wxImage *arg1 = (wxImage *) 0 ;
13878 wxRect *arg2 = 0 ;
13879 byte arg3 ;
13880 byte arg4 ;
13881 byte arg5 ;
13882 void *argp1 = 0 ;
13883 int res1 = 0 ;
13884 wxRect temp2 ;
13885 unsigned char val3 ;
13886 int ecode3 = 0 ;
13887 unsigned char val4 ;
13888 int ecode4 = 0 ;
13889 unsigned char val5 ;
13890 int ecode5 = 0 ;
13891 PyObject * obj0 = 0 ;
13892 PyObject * obj1 = 0 ;
13893 PyObject * obj2 = 0 ;
13894 PyObject * obj3 = 0 ;
13895 PyObject * obj4 = 0 ;
13896 char * kwnames[] = {
13897 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13898 };
13899
13900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13902 if (!SWIG_IsOK(res1)) {
13903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13904 }
13905 arg1 = reinterpret_cast< wxImage * >(argp1);
13906 {
13907 arg2 = &temp2;
13908 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13909 }
13910 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13911 if (!SWIG_IsOK(ecode3)) {
13912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13913 }
13914 arg3 = static_cast< byte >(val3);
13915 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13916 if (!SWIG_IsOK(ecode4)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13918 }
13919 arg4 = static_cast< byte >(val4);
13920 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13921 if (!SWIG_IsOK(ecode5)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13923 }
13924 arg5 = static_cast< byte >(val5);
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_Py_Void();
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj = 0;
13940 wxImage *arg1 = (wxImage *) 0 ;
13941 int arg2 ;
13942 int arg3 ;
13943 byte result;
13944 void *argp1 = 0 ;
13945 int res1 = 0 ;
13946 int val2 ;
13947 int ecode2 = 0 ;
13948 int val3 ;
13949 int ecode3 = 0 ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 PyObject * obj2 = 0 ;
13953 char * kwnames[] = {
13954 (char *) "self",(char *) "x",(char *) "y", NULL
13955 };
13956
13957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13959 if (!SWIG_IsOK(res1)) {
13960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13961 }
13962 arg1 = reinterpret_cast< wxImage * >(argp1);
13963 ecode2 = SWIG_AsVal_int(obj1, &val2);
13964 if (!SWIG_IsOK(ecode2)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13966 }
13967 arg2 = static_cast< int >(val2);
13968 ecode3 = SWIG_AsVal_int(obj2, &val3);
13969 if (!SWIG_IsOK(ecode3)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13971 }
13972 arg3 = static_cast< int >(val3);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (byte)(arg1)->GetRed(arg2,arg3);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj = 0;
13988 wxImage *arg1 = (wxImage *) 0 ;
13989 int arg2 ;
13990 int arg3 ;
13991 byte result;
13992 void *argp1 = 0 ;
13993 int res1 = 0 ;
13994 int val2 ;
13995 int ecode2 = 0 ;
13996 int val3 ;
13997 int ecode3 = 0 ;
13998 PyObject * obj0 = 0 ;
13999 PyObject * obj1 = 0 ;
14000 PyObject * obj2 = 0 ;
14001 char * kwnames[] = {
14002 (char *) "self",(char *) "x",(char *) "y", NULL
14003 };
14004
14005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14007 if (!SWIG_IsOK(res1)) {
14008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14009 }
14010 arg1 = reinterpret_cast< wxImage * >(argp1);
14011 ecode2 = SWIG_AsVal_int(obj1, &val2);
14012 if (!SWIG_IsOK(ecode2)) {
14013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14014 }
14015 arg2 = static_cast< int >(val2);
14016 ecode3 = SWIG_AsVal_int(obj2, &val3);
14017 if (!SWIG_IsOK(ecode3)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14019 }
14020 arg3 = static_cast< int >(val3);
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (byte)(arg1)->GetGreen(arg2,arg3);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14035 PyObject *resultobj = 0;
14036 wxImage *arg1 = (wxImage *) 0 ;
14037 int arg2 ;
14038 int arg3 ;
14039 byte result;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 int val2 ;
14043 int ecode2 = 0 ;
14044 int val3 ;
14045 int ecode3 = 0 ;
14046 PyObject * obj0 = 0 ;
14047 PyObject * obj1 = 0 ;
14048 PyObject * obj2 = 0 ;
14049 char * kwnames[] = {
14050 (char *) "self",(char *) "x",(char *) "y", NULL
14051 };
14052
14053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14055 if (!SWIG_IsOK(res1)) {
14056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14057 }
14058 arg1 = reinterpret_cast< wxImage * >(argp1);
14059 ecode2 = SWIG_AsVal_int(obj1, &val2);
14060 if (!SWIG_IsOK(ecode2)) {
14061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14062 }
14063 arg2 = static_cast< int >(val2);
14064 ecode3 = SWIG_AsVal_int(obj2, &val3);
14065 if (!SWIG_IsOK(ecode3)) {
14066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14067 }
14068 arg3 = static_cast< int >(val3);
14069 {
14070 PyThreadState* __tstate = wxPyBeginAllowThreads();
14071 result = (byte)(arg1)->GetBlue(arg2,arg3);
14072 wxPyEndAllowThreads(__tstate);
14073 if (PyErr_Occurred()) SWIG_fail;
14074 }
14075 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14076 return resultobj;
14077 fail:
14078 return NULL;
14079 }
14080
14081
14082 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14083 PyObject *resultobj = 0;
14084 wxImage *arg1 = (wxImage *) 0 ;
14085 int arg2 ;
14086 int arg3 ;
14087 byte arg4 ;
14088 void *argp1 = 0 ;
14089 int res1 = 0 ;
14090 int val2 ;
14091 int ecode2 = 0 ;
14092 int val3 ;
14093 int ecode3 = 0 ;
14094 unsigned char val4 ;
14095 int ecode4 = 0 ;
14096 PyObject * obj0 = 0 ;
14097 PyObject * obj1 = 0 ;
14098 PyObject * obj2 = 0 ;
14099 PyObject * obj3 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14108 }
14109 arg1 = reinterpret_cast< wxImage * >(argp1);
14110 ecode2 = SWIG_AsVal_int(obj1, &val2);
14111 if (!SWIG_IsOK(ecode2)) {
14112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14113 }
14114 arg2 = static_cast< int >(val2);
14115 ecode3 = SWIG_AsVal_int(obj2, &val3);
14116 if (!SWIG_IsOK(ecode3)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14118 }
14119 arg3 = static_cast< int >(val3);
14120 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14121 if (!SWIG_IsOK(ecode4)) {
14122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14123 }
14124 arg4 = static_cast< byte >(val4);
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 (arg1)->SetAlpha(arg2,arg3,arg4);
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 resultobj = SWIG_Py_Void();
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj = 0;
14140 wxImage *arg1 = (wxImage *) 0 ;
14141 int arg2 ;
14142 int arg3 ;
14143 byte result;
14144 void *argp1 = 0 ;
14145 int res1 = 0 ;
14146 int val2 ;
14147 int ecode2 = 0 ;
14148 int val3 ;
14149 int ecode3 = 0 ;
14150 PyObject * obj0 = 0 ;
14151 PyObject * obj1 = 0 ;
14152 PyObject * obj2 = 0 ;
14153 char * kwnames[] = {
14154 (char *) "self",(char *) "x",(char *) "y", NULL
14155 };
14156
14157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14159 if (!SWIG_IsOK(res1)) {
14160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14161 }
14162 arg1 = reinterpret_cast< wxImage * >(argp1);
14163 ecode2 = SWIG_AsVal_int(obj1, &val2);
14164 if (!SWIG_IsOK(ecode2)) {
14165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14166 }
14167 arg2 = static_cast< int >(val2);
14168 ecode3 = SWIG_AsVal_int(obj2, &val3);
14169 if (!SWIG_IsOK(ecode3)) {
14170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14171 }
14172 arg3 = static_cast< int >(val3);
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14180 return resultobj;
14181 fail:
14182 return NULL;
14183 }
14184
14185
14186 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14187 PyObject *resultobj = 0;
14188 wxImage *arg1 = (wxImage *) 0 ;
14189 bool result;
14190 void *argp1 = 0 ;
14191 int res1 = 0 ;
14192 PyObject *swig_obj[1] ;
14193
14194 if (!args) SWIG_fail;
14195 swig_obj[0] = args;
14196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14197 if (!SWIG_IsOK(res1)) {
14198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14199 }
14200 arg1 = reinterpret_cast< wxImage * >(argp1);
14201 {
14202 PyThreadState* __tstate = wxPyBeginAllowThreads();
14203 result = (bool)(arg1)->HasAlpha();
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14209 }
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14217 PyObject *resultobj = 0;
14218 wxImage *arg1 = (wxImage *) 0 ;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 PyObject *swig_obj[1] ;
14222
14223 if (!args) SWIG_fail;
14224 swig_obj[0] = args;
14225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14226 if (!SWIG_IsOK(res1)) {
14227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14228 }
14229 arg1 = reinterpret_cast< wxImage * >(argp1);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 (arg1)->InitAlpha();
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_Py_Void();
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 wxImage *arg1 = (wxImage *) 0 ;
14246 int arg2 ;
14247 int arg3 ;
14248 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14249 bool result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 int val2 ;
14253 int ecode2 = 0 ;
14254 int val3 ;
14255 int ecode3 = 0 ;
14256 unsigned char val4 ;
14257 int ecode4 = 0 ;
14258 PyObject * obj0 = 0 ;
14259 PyObject * obj1 = 0 ;
14260 PyObject * obj2 = 0 ;
14261 PyObject * obj3 = 0 ;
14262 char * kwnames[] = {
14263 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14264 };
14265
14266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14268 if (!SWIG_IsOK(res1)) {
14269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14270 }
14271 arg1 = reinterpret_cast< wxImage * >(argp1);
14272 ecode2 = SWIG_AsVal_int(obj1, &val2);
14273 if (!SWIG_IsOK(ecode2)) {
14274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14275 }
14276 arg2 = static_cast< int >(val2);
14277 ecode3 = SWIG_AsVal_int(obj2, &val3);
14278 if (!SWIG_IsOK(ecode3)) {
14279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14280 }
14281 arg3 = static_cast< int >(val3);
14282 if (obj3) {
14283 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14284 if (!SWIG_IsOK(ecode4)) {
14285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14286 }
14287 arg4 = static_cast< byte >(val4);
14288 }
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 {
14296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14297 }
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14305 PyObject *resultobj = 0;
14306 wxImage *arg1 = (wxImage *) 0 ;
14307 byte *arg2 = (byte *) 0 ;
14308 byte *arg3 = (byte *) 0 ;
14309 byte *arg4 = (byte *) 0 ;
14310 byte arg5 = (byte) 0 ;
14311 byte arg6 = (byte) 0 ;
14312 byte arg7 = (byte) 0 ;
14313 bool result;
14314 void *argp1 = 0 ;
14315 int res1 = 0 ;
14316 byte temp2 ;
14317 int res2 = SWIG_TMPOBJ ;
14318 byte temp3 ;
14319 int res3 = SWIG_TMPOBJ ;
14320 byte temp4 ;
14321 int res4 = SWIG_TMPOBJ ;
14322 unsigned char val5 ;
14323 int ecode5 = 0 ;
14324 unsigned char val6 ;
14325 int ecode6 = 0 ;
14326 unsigned char val7 ;
14327 int ecode7 = 0 ;
14328 PyObject * obj0 = 0 ;
14329 PyObject * obj1 = 0 ;
14330 PyObject * obj2 = 0 ;
14331 PyObject * obj3 = 0 ;
14332 char * kwnames[] = {
14333 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14334 };
14335
14336 arg2 = &temp2;
14337 arg3 = &temp3;
14338 arg4 = &temp4;
14339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14341 if (!SWIG_IsOK(res1)) {
14342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14343 }
14344 arg1 = reinterpret_cast< wxImage * >(argp1);
14345 if (obj1) {
14346 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14347 if (!SWIG_IsOK(ecode5)) {
14348 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14349 }
14350 arg5 = static_cast< byte >(val5);
14351 }
14352 if (obj2) {
14353 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14354 if (!SWIG_IsOK(ecode6)) {
14355 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14356 }
14357 arg6 = static_cast< byte >(val6);
14358 }
14359 if (obj3) {
14360 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14361 if (!SWIG_IsOK(ecode7)) {
14362 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14363 }
14364 arg7 = static_cast< byte >(val7);
14365 }
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 {
14373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14374 }
14375 if (SWIG_IsTmpObj(res2)) {
14376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14377 } else {
14378 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14380 }
14381 if (SWIG_IsTmpObj(res3)) {
14382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14383 } else {
14384 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14386 }
14387 if (SWIG_IsTmpObj(res4)) {
14388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14389 } else {
14390 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14392 }
14393 return resultobj;
14394 fail:
14395 return NULL;
14396 }
14397
14398
14399 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14400 PyObject *resultobj = 0;
14401 wxImage *arg1 = (wxImage *) 0 ;
14402 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14403 bool result;
14404 void *argp1 = 0 ;
14405 int res1 = 0 ;
14406 unsigned char val2 ;
14407 int ecode2 = 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 char * kwnames[] = {
14411 (char *) "self",(char *) "threshold", NULL
14412 };
14413
14414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14416 if (!SWIG_IsOK(res1)) {
14417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14418 }
14419 arg1 = reinterpret_cast< wxImage * >(argp1);
14420 if (obj1) {
14421 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14422 if (!SWIG_IsOK(ecode2)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14424 }
14425 arg2 = static_cast< byte >(val2);
14426 }
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 {
14434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14435 }
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj = 0;
14444 wxImage *arg1 = (wxImage *) 0 ;
14445 byte arg2 ;
14446 byte arg3 ;
14447 byte arg4 ;
14448 bool result;
14449 void *argp1 = 0 ;
14450 int res1 = 0 ;
14451 unsigned char val2 ;
14452 int ecode2 = 0 ;
14453 unsigned char val3 ;
14454 int ecode3 = 0 ;
14455 unsigned char val4 ;
14456 int ecode4 = 0 ;
14457 PyObject * obj0 = 0 ;
14458 PyObject * obj1 = 0 ;
14459 PyObject * obj2 = 0 ;
14460 PyObject * obj3 = 0 ;
14461 char * kwnames[] = {
14462 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14463 };
14464
14465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14467 if (!SWIG_IsOK(res1)) {
14468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14469 }
14470 arg1 = reinterpret_cast< wxImage * >(argp1);
14471 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14472 if (!SWIG_IsOK(ecode2)) {
14473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14474 }
14475 arg2 = static_cast< byte >(val2);
14476 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14477 if (!SWIG_IsOK(ecode3)) {
14478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14479 }
14480 arg3 = static_cast< byte >(val3);
14481 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14482 if (!SWIG_IsOK(ecode4)) {
14483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14484 }
14485 arg4 = static_cast< byte >(val4);
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 {
14493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14494 }
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj = 0;
14503 wxImage *arg1 = (wxImage *) 0 ;
14504 wxImage *arg2 = 0 ;
14505 byte arg3 ;
14506 byte arg4 ;
14507 byte arg5 ;
14508 bool result;
14509 void *argp1 = 0 ;
14510 int res1 = 0 ;
14511 void *argp2 = 0 ;
14512 int res2 = 0 ;
14513 unsigned char val3 ;
14514 int ecode3 = 0 ;
14515 unsigned char val4 ;
14516 int ecode4 = 0 ;
14517 unsigned char val5 ;
14518 int ecode5 = 0 ;
14519 PyObject * obj0 = 0 ;
14520 PyObject * obj1 = 0 ;
14521 PyObject * obj2 = 0 ;
14522 PyObject * obj3 = 0 ;
14523 PyObject * obj4 = 0 ;
14524 char * kwnames[] = {
14525 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14526 };
14527
14528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14530 if (!SWIG_IsOK(res1)) {
14531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14532 }
14533 arg1 = reinterpret_cast< wxImage * >(argp1);
14534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14535 if (!SWIG_IsOK(res2)) {
14536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14537 }
14538 if (!argp2) {
14539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14540 }
14541 arg2 = reinterpret_cast< wxImage * >(argp2);
14542 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14543 if (!SWIG_IsOK(ecode3)) {
14544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14545 }
14546 arg3 = static_cast< byte >(val3);
14547 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14548 if (!SWIG_IsOK(ecode4)) {
14549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14550 }
14551 arg4 = static_cast< byte >(val4);
14552 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14553 if (!SWIG_IsOK(ecode5)) {
14554 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14555 }
14556 arg5 = static_cast< byte >(val5);
14557 {
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14560 wxPyEndAllowThreads(__tstate);
14561 if (PyErr_Occurred()) SWIG_fail;
14562 }
14563 {
14564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14565 }
14566 return resultobj;
14567 fail:
14568 return NULL;
14569 }
14570
14571
14572 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj = 0;
14574 wxString *arg1 = 0 ;
14575 bool result;
14576 bool temp1 = false ;
14577 PyObject * obj0 = 0 ;
14578 char * kwnames[] = {
14579 (char *) "filename", NULL
14580 };
14581
14582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14583 {
14584 arg1 = wxString_in_helper(obj0);
14585 if (arg1 == NULL) SWIG_fail;
14586 temp1 = true;
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 {
14595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14596 }
14597 {
14598 if (temp1)
14599 delete arg1;
14600 }
14601 return resultobj;
14602 fail:
14603 {
14604 if (temp1)
14605 delete arg1;
14606 }
14607 return NULL;
14608 }
14609
14610
14611 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14612 PyObject *resultobj = 0;
14613 wxString *arg1 = 0 ;
14614 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14615 int result;
14616 bool temp1 = false ;
14617 long val2 ;
14618 int ecode2 = 0 ;
14619 PyObject * obj0 = 0 ;
14620 PyObject * obj1 = 0 ;
14621 char * kwnames[] = {
14622 (char *) "filename",(char *) "type", NULL
14623 };
14624
14625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14626 {
14627 arg1 = wxString_in_helper(obj0);
14628 if (arg1 == NULL) SWIG_fail;
14629 temp1 = true;
14630 }
14631 if (obj1) {
14632 ecode2 = SWIG_AsVal_long(obj1, &val2);
14633 if (!SWIG_IsOK(ecode2)) {
14634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14635 }
14636 arg2 = static_cast< long >(val2);
14637 }
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 resultobj = SWIG_From_int(static_cast< int >(result));
14645 {
14646 if (temp1)
14647 delete arg1;
14648 }
14649 return resultobj;
14650 fail:
14651 {
14652 if (temp1)
14653 delete arg1;
14654 }
14655 return NULL;
14656 }
14657
14658
14659 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14660 PyObject *resultobj = 0;
14661 wxImage *arg1 = (wxImage *) 0 ;
14662 wxString *arg2 = 0 ;
14663 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14664 int arg4 = (int) -1 ;
14665 bool result;
14666 void *argp1 = 0 ;
14667 int res1 = 0 ;
14668 bool temp2 = false ;
14669 long val3 ;
14670 int ecode3 = 0 ;
14671 int val4 ;
14672 int ecode4 = 0 ;
14673 PyObject * obj0 = 0 ;
14674 PyObject * obj1 = 0 ;
14675 PyObject * obj2 = 0 ;
14676 PyObject * obj3 = 0 ;
14677 char * kwnames[] = {
14678 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14679 };
14680
14681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14683 if (!SWIG_IsOK(res1)) {
14684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14685 }
14686 arg1 = reinterpret_cast< wxImage * >(argp1);
14687 {
14688 arg2 = wxString_in_helper(obj1);
14689 if (arg2 == NULL) SWIG_fail;
14690 temp2 = true;
14691 }
14692 if (obj2) {
14693 ecode3 = SWIG_AsVal_long(obj2, &val3);
14694 if (!SWIG_IsOK(ecode3)) {
14695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14696 }
14697 arg3 = static_cast< long >(val3);
14698 }
14699 if (obj3) {
14700 ecode4 = SWIG_AsVal_int(obj3, &val4);
14701 if (!SWIG_IsOK(ecode4)) {
14702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14703 }
14704 arg4 = static_cast< int >(val4);
14705 }
14706 {
14707 PyThreadState* __tstate = wxPyBeginAllowThreads();
14708 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14709 wxPyEndAllowThreads(__tstate);
14710 if (PyErr_Occurred()) SWIG_fail;
14711 }
14712 {
14713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14714 }
14715 {
14716 if (temp2)
14717 delete arg2;
14718 }
14719 return resultobj;
14720 fail:
14721 {
14722 if (temp2)
14723 delete arg2;
14724 }
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14730 PyObject *resultobj = 0;
14731 wxImage *arg1 = (wxImage *) 0 ;
14732 wxString *arg2 = 0 ;
14733 wxString *arg3 = 0 ;
14734 int arg4 = (int) -1 ;
14735 bool result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 bool temp2 = false ;
14739 bool temp3 = false ;
14740 int val4 ;
14741 int ecode4 = 0 ;
14742 PyObject * obj0 = 0 ;
14743 PyObject * obj1 = 0 ;
14744 PyObject * obj2 = 0 ;
14745 PyObject * obj3 = 0 ;
14746 char * kwnames[] = {
14747 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14748 };
14749
14750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14752 if (!SWIG_IsOK(res1)) {
14753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14754 }
14755 arg1 = reinterpret_cast< wxImage * >(argp1);
14756 {
14757 arg2 = wxString_in_helper(obj1);
14758 if (arg2 == NULL) SWIG_fail;
14759 temp2 = true;
14760 }
14761 {
14762 arg3 = wxString_in_helper(obj2);
14763 if (arg3 == NULL) SWIG_fail;
14764 temp3 = true;
14765 }
14766 if (obj3) {
14767 ecode4 = SWIG_AsVal_int(obj3, &val4);
14768 if (!SWIG_IsOK(ecode4)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14770 }
14771 arg4 = static_cast< int >(val4);
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (temp2)
14784 delete arg2;
14785 }
14786 {
14787 if (temp3)
14788 delete arg3;
14789 }
14790 return resultobj;
14791 fail:
14792 {
14793 if (temp2)
14794 delete arg2;
14795 }
14796 {
14797 if (temp3)
14798 delete arg3;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj = 0;
14806 wxImage *arg1 = (wxImage *) 0 ;
14807 wxString *arg2 = 0 ;
14808 int arg3 ;
14809 bool result;
14810 void *argp1 = 0 ;
14811 int res1 = 0 ;
14812 bool temp2 = false ;
14813 int val3 ;
14814 int ecode3 = 0 ;
14815 PyObject * obj0 = 0 ;
14816 PyObject * obj1 = 0 ;
14817 PyObject * obj2 = 0 ;
14818 char * kwnames[] = {
14819 (char *) "self",(char *) "name",(char *) "type", NULL
14820 };
14821
14822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14824 if (!SWIG_IsOK(res1)) {
14825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14826 }
14827 arg1 = reinterpret_cast< wxImage * >(argp1);
14828 {
14829 arg2 = wxString_in_helper(obj1);
14830 if (arg2 == NULL) SWIG_fail;
14831 temp2 = true;
14832 }
14833 ecode3 = SWIG_AsVal_int(obj2, &val3);
14834 if (!SWIG_IsOK(ecode3)) {
14835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14836 }
14837 arg3 = static_cast< int >(val3);
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14841 wxPyEndAllowThreads(__tstate);
14842 if (PyErr_Occurred()) SWIG_fail;
14843 }
14844 {
14845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14846 }
14847 {
14848 if (temp2)
14849 delete arg2;
14850 }
14851 return resultobj;
14852 fail:
14853 {
14854 if (temp2)
14855 delete arg2;
14856 }
14857 return NULL;
14858 }
14859
14860
14861 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj = 0;
14863 wxImage *arg1 = (wxImage *) 0 ;
14864 wxString *arg2 = 0 ;
14865 wxString *arg3 = 0 ;
14866 bool result;
14867 void *argp1 = 0 ;
14868 int res1 = 0 ;
14869 bool temp2 = false ;
14870 bool temp3 = false ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 PyObject * obj2 = 0 ;
14874 char * kwnames[] = {
14875 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14876 };
14877
14878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14880 if (!SWIG_IsOK(res1)) {
14881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14882 }
14883 arg1 = reinterpret_cast< wxImage * >(argp1);
14884 {
14885 arg2 = wxString_in_helper(obj1);
14886 if (arg2 == NULL) SWIG_fail;
14887 temp2 = true;
14888 }
14889 {
14890 arg3 = wxString_in_helper(obj2);
14891 if (arg3 == NULL) SWIG_fail;
14892 temp3 = true;
14893 }
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 {
14901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14902 }
14903 {
14904 if (temp2)
14905 delete arg2;
14906 }
14907 {
14908 if (temp3)
14909 delete arg3;
14910 }
14911 return resultobj;
14912 fail:
14913 {
14914 if (temp2)
14915 delete arg2;
14916 }
14917 {
14918 if (temp3)
14919 delete arg3;
14920 }
14921 return NULL;
14922 }
14923
14924
14925 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj = 0;
14927 wxInputStream *arg1 = 0 ;
14928 bool result;
14929 wxPyInputStream *temp1 ;
14930 bool created1 ;
14931 PyObject * obj0 = 0 ;
14932 char * kwnames[] = {
14933 (char *) "stream", NULL
14934 };
14935
14936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14937 {
14938 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14939 arg1 = temp1->m_wxis;
14940 created1 = false;
14941 } else {
14942 PyErr_Clear(); // clear the failure of the wxPyConvert above
14943 arg1 = wxPyCBInputStream_create(obj0, false);
14944 if (arg1 == NULL) {
14945 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14946 SWIG_fail;
14947 }
14948 created1 = true;
14949 }
14950 }
14951 {
14952 PyThreadState* __tstate = wxPyBeginAllowThreads();
14953 result = (bool)wxImage::CanRead(*arg1);
14954 wxPyEndAllowThreads(__tstate);
14955 if (PyErr_Occurred()) SWIG_fail;
14956 }
14957 {
14958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14959 }
14960 {
14961 if (created1) delete arg1;
14962 }
14963 return resultobj;
14964 fail:
14965 {
14966 if (created1) delete arg1;
14967 }
14968 return NULL;
14969 }
14970
14971
14972 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj = 0;
14974 wxImage *arg1 = (wxImage *) 0 ;
14975 wxInputStream *arg2 = 0 ;
14976 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14977 int arg4 = (int) -1 ;
14978 bool result;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 wxPyInputStream *temp2 ;
14982 bool created2 ;
14983 long val3 ;
14984 int ecode3 = 0 ;
14985 int val4 ;
14986 int ecode4 = 0 ;
14987 PyObject * obj0 = 0 ;
14988 PyObject * obj1 = 0 ;
14989 PyObject * obj2 = 0 ;
14990 PyObject * obj3 = 0 ;
14991 char * kwnames[] = {
14992 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14993 };
14994
14995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14997 if (!SWIG_IsOK(res1)) {
14998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14999 }
15000 arg1 = reinterpret_cast< wxImage * >(argp1);
15001 {
15002 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15003 arg2 = temp2->m_wxis;
15004 created2 = false;
15005 } else {
15006 PyErr_Clear(); // clear the failure of the wxPyConvert above
15007 arg2 = wxPyCBInputStream_create(obj1, false);
15008 if (arg2 == NULL) {
15009 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15010 SWIG_fail;
15011 }
15012 created2 = true;
15013 }
15014 }
15015 if (obj2) {
15016 ecode3 = SWIG_AsVal_long(obj2, &val3);
15017 if (!SWIG_IsOK(ecode3)) {
15018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15019 }
15020 arg3 = static_cast< long >(val3);
15021 }
15022 if (obj3) {
15023 ecode4 = SWIG_AsVal_int(obj3, &val4);
15024 if (!SWIG_IsOK(ecode4)) {
15025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15026 }
15027 arg4 = static_cast< int >(val4);
15028 }
15029 {
15030 PyThreadState* __tstate = wxPyBeginAllowThreads();
15031 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15032 wxPyEndAllowThreads(__tstate);
15033 if (PyErr_Occurred()) SWIG_fail;
15034 }
15035 {
15036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15037 }
15038 {
15039 if (created2) delete arg2;
15040 }
15041 return resultobj;
15042 fail:
15043 {
15044 if (created2) delete arg2;
15045 }
15046 return NULL;
15047 }
15048
15049
15050 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15051 PyObject *resultobj = 0;
15052 wxImage *arg1 = (wxImage *) 0 ;
15053 wxInputStream *arg2 = 0 ;
15054 wxString *arg3 = 0 ;
15055 int arg4 = (int) -1 ;
15056 bool result;
15057 void *argp1 = 0 ;
15058 int res1 = 0 ;
15059 wxPyInputStream *temp2 ;
15060 bool created2 ;
15061 bool temp3 = false ;
15062 int val4 ;
15063 int ecode4 = 0 ;
15064 PyObject * obj0 = 0 ;
15065 PyObject * obj1 = 0 ;
15066 PyObject * obj2 = 0 ;
15067 PyObject * obj3 = 0 ;
15068 char * kwnames[] = {
15069 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15070 };
15071
15072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15074 if (!SWIG_IsOK(res1)) {
15075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15076 }
15077 arg1 = reinterpret_cast< wxImage * >(argp1);
15078 {
15079 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15080 arg2 = temp2->m_wxis;
15081 created2 = false;
15082 } else {
15083 PyErr_Clear(); // clear the failure of the wxPyConvert above
15084 arg2 = wxPyCBInputStream_create(obj1, false);
15085 if (arg2 == NULL) {
15086 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15087 SWIG_fail;
15088 }
15089 created2 = true;
15090 }
15091 }
15092 {
15093 arg3 = wxString_in_helper(obj2);
15094 if (arg3 == NULL) SWIG_fail;
15095 temp3 = true;
15096 }
15097 if (obj3) {
15098 ecode4 = SWIG_AsVal_int(obj3, &val4);
15099 if (!SWIG_IsOK(ecode4)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15101 }
15102 arg4 = static_cast< int >(val4);
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 {
15111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15112 }
15113 {
15114 if (created2) delete arg2;
15115 }
15116 {
15117 if (temp3)
15118 delete arg3;
15119 }
15120 return resultobj;
15121 fail:
15122 {
15123 if (created2) delete arg2;
15124 }
15125 {
15126 if (temp3)
15127 delete arg3;
15128 }
15129 return NULL;
15130 }
15131
15132
15133 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15134 PyObject *resultobj = 0;
15135 wxImage *arg1 = (wxImage *) 0 ;
15136 bool result;
15137 void *argp1 = 0 ;
15138 int res1 = 0 ;
15139 PyObject *swig_obj[1] ;
15140
15141 if (!args) SWIG_fail;
15142 swig_obj[0] = args;
15143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15144 if (!SWIG_IsOK(res1)) {
15145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15146 }
15147 arg1 = reinterpret_cast< wxImage * >(argp1);
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (bool)(arg1)->Ok();
15151 wxPyEndAllowThreads(__tstate);
15152 if (PyErr_Occurred()) SWIG_fail;
15153 }
15154 {
15155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15156 }
15157 return resultobj;
15158 fail:
15159 return NULL;
15160 }
15161
15162
15163 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15164 PyObject *resultobj = 0;
15165 wxImage *arg1 = (wxImage *) 0 ;
15166 int result;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 PyObject *swig_obj[1] ;
15170
15171 if (!args) SWIG_fail;
15172 swig_obj[0] = args;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15176 }
15177 arg1 = reinterpret_cast< wxImage * >(argp1);
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (int)(arg1)->GetWidth();
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 resultobj = SWIG_From_int(static_cast< int >(result));
15185 return resultobj;
15186 fail:
15187 return NULL;
15188 }
15189
15190
15191 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15192 PyObject *resultobj = 0;
15193 wxImage *arg1 = (wxImage *) 0 ;
15194 int result;
15195 void *argp1 = 0 ;
15196 int res1 = 0 ;
15197 PyObject *swig_obj[1] ;
15198
15199 if (!args) SWIG_fail;
15200 swig_obj[0] = args;
15201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15202 if (!SWIG_IsOK(res1)) {
15203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15204 }
15205 arg1 = reinterpret_cast< wxImage * >(argp1);
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = (int)(arg1)->GetHeight();
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 resultobj = SWIG_From_int(static_cast< int >(result));
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15220 PyObject *resultobj = 0;
15221 wxImage *arg1 = (wxImage *) 0 ;
15222 wxSize result;
15223 void *argp1 = 0 ;
15224 int res1 = 0 ;
15225 PyObject *swig_obj[1] ;
15226
15227 if (!args) SWIG_fail;
15228 swig_obj[0] = args;
15229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15230 if (!SWIG_IsOK(res1)) {
15231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15232 }
15233 arg1 = reinterpret_cast< wxImage * >(argp1);
15234 {
15235 PyThreadState* __tstate = wxPyBeginAllowThreads();
15236 result = wxImage_GetSize(arg1);
15237 wxPyEndAllowThreads(__tstate);
15238 if (PyErr_Occurred()) SWIG_fail;
15239 }
15240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15241 return resultobj;
15242 fail:
15243 return NULL;
15244 }
15245
15246
15247 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15248 PyObject *resultobj = 0;
15249 wxImage *arg1 = (wxImage *) 0 ;
15250 wxRect *arg2 = 0 ;
15251 SwigValueWrapper<wxImage > result;
15252 void *argp1 = 0 ;
15253 int res1 = 0 ;
15254 wxRect temp2 ;
15255 PyObject * obj0 = 0 ;
15256 PyObject * obj1 = 0 ;
15257 char * kwnames[] = {
15258 (char *) "self",(char *) "rect", NULL
15259 };
15260
15261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15265 }
15266 arg1 = reinterpret_cast< wxImage * >(argp1);
15267 {
15268 arg2 = &temp2;
15269 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15270 }
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15278 return resultobj;
15279 fail:
15280 return NULL;
15281 }
15282
15283
15284 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15285 PyObject *resultobj = 0;
15286 wxImage *arg1 = (wxImage *) 0 ;
15287 wxSize *arg2 = 0 ;
15288 wxPoint *arg3 = 0 ;
15289 int arg4 = (int) -1 ;
15290 int arg5 = (int) -1 ;
15291 int arg6 = (int) -1 ;
15292 SwigValueWrapper<wxImage > result;
15293 void *argp1 = 0 ;
15294 int res1 = 0 ;
15295 wxSize temp2 ;
15296 wxPoint temp3 ;
15297 int val4 ;
15298 int ecode4 = 0 ;
15299 int val5 ;
15300 int ecode5 = 0 ;
15301 int val6 ;
15302 int ecode6 = 0 ;
15303 PyObject * obj0 = 0 ;
15304 PyObject * obj1 = 0 ;
15305 PyObject * obj2 = 0 ;
15306 PyObject * obj3 = 0 ;
15307 PyObject * obj4 = 0 ;
15308 PyObject * obj5 = 0 ;
15309 char * kwnames[] = {
15310 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15311 };
15312
15313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15315 if (!SWIG_IsOK(res1)) {
15316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15317 }
15318 arg1 = reinterpret_cast< wxImage * >(argp1);
15319 {
15320 arg2 = &temp2;
15321 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15322 }
15323 {
15324 arg3 = &temp3;
15325 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15326 }
15327 if (obj3) {
15328 ecode4 = SWIG_AsVal_int(obj3, &val4);
15329 if (!SWIG_IsOK(ecode4)) {
15330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15331 }
15332 arg4 = static_cast< int >(val4);
15333 }
15334 if (obj4) {
15335 ecode5 = SWIG_AsVal_int(obj4, &val5);
15336 if (!SWIG_IsOK(ecode5)) {
15337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15338 }
15339 arg5 = static_cast< int >(val5);
15340 }
15341 if (obj5) {
15342 ecode6 = SWIG_AsVal_int(obj5, &val6);
15343 if (!SWIG_IsOK(ecode6)) {
15344 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15345 }
15346 arg6 = static_cast< int >(val6);
15347 }
15348 {
15349 PyThreadState* __tstate = wxPyBeginAllowThreads();
15350 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15351 wxPyEndAllowThreads(__tstate);
15352 if (PyErr_Occurred()) SWIG_fail;
15353 }
15354 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15355 return resultobj;
15356 fail:
15357 return NULL;
15358 }
15359
15360
15361 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15362 PyObject *resultobj = 0;
15363 wxImage *arg1 = (wxImage *) 0 ;
15364 SwigValueWrapper<wxImage > result;
15365 void *argp1 = 0 ;
15366 int res1 = 0 ;
15367 PyObject *swig_obj[1] ;
15368
15369 if (!args) SWIG_fail;
15370 swig_obj[0] = args;
15371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15372 if (!SWIG_IsOK(res1)) {
15373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15374 }
15375 arg1 = reinterpret_cast< wxImage * >(argp1);
15376 {
15377 PyThreadState* __tstate = wxPyBeginAllowThreads();
15378 result = (arg1)->Copy();
15379 wxPyEndAllowThreads(__tstate);
15380 if (PyErr_Occurred()) SWIG_fail;
15381 }
15382 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15383 return resultobj;
15384 fail:
15385 return NULL;
15386 }
15387
15388
15389 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15390 PyObject *resultobj = 0;
15391 wxImage *arg1 = (wxImage *) 0 ;
15392 wxImage *arg2 = 0 ;
15393 int arg3 ;
15394 int arg4 ;
15395 void *argp1 = 0 ;
15396 int res1 = 0 ;
15397 void *argp2 = 0 ;
15398 int res2 = 0 ;
15399 int val3 ;
15400 int ecode3 = 0 ;
15401 int val4 ;
15402 int ecode4 = 0 ;
15403 PyObject * obj0 = 0 ;
15404 PyObject * obj1 = 0 ;
15405 PyObject * obj2 = 0 ;
15406 PyObject * obj3 = 0 ;
15407 char * kwnames[] = {
15408 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15409 };
15410
15411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15413 if (!SWIG_IsOK(res1)) {
15414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15415 }
15416 arg1 = reinterpret_cast< wxImage * >(argp1);
15417 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15418 if (!SWIG_IsOK(res2)) {
15419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15420 }
15421 if (!argp2) {
15422 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15423 }
15424 arg2 = reinterpret_cast< wxImage * >(argp2);
15425 ecode3 = SWIG_AsVal_int(obj2, &val3);
15426 if (!SWIG_IsOK(ecode3)) {
15427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15428 }
15429 arg3 = static_cast< int >(val3);
15430 ecode4 = SWIG_AsVal_int(obj3, &val4);
15431 if (!SWIG_IsOK(ecode4)) {
15432 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15433 }
15434 arg4 = static_cast< int >(val4);
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_Py_Void();
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15449 PyObject *resultobj = 0;
15450 wxImage *arg1 = (wxImage *) 0 ;
15451 PyObject *result = 0 ;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 PyObject *swig_obj[1] ;
15455
15456 if (!args) SWIG_fail;
15457 swig_obj[0] = args;
15458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15459 if (!SWIG_IsOK(res1)) {
15460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15461 }
15462 arg1 = reinterpret_cast< wxImage * >(argp1);
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 result = (PyObject *)wxImage_GetData(arg1);
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 resultobj = result;
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15477 PyObject *resultobj = 0;
15478 wxImage *arg1 = (wxImage *) 0 ;
15479 buffer arg2 ;
15480 int arg3 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 PyObject * obj0 = 0 ;
15484 PyObject * obj1 = 0 ;
15485 char * kwnames[] = {
15486 (char *) "self",(char *) "data", NULL
15487 };
15488
15489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15491 if (!SWIG_IsOK(res1)) {
15492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15493 }
15494 arg1 = reinterpret_cast< wxImage * >(argp1);
15495 {
15496 if (obj1 != Py_None) {
15497 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15498 }
15499 }
15500 {
15501 PyThreadState* __tstate = wxPyBeginAllowThreads();
15502 wxImage_SetData(arg1,arg2,arg3);
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 resultobj = SWIG_Py_Void();
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15514 PyObject *resultobj = 0;
15515 wxImage *arg1 = (wxImage *) 0 ;
15516 PyObject *result = 0 ;
15517 void *argp1 = 0 ;
15518 int res1 = 0 ;
15519 PyObject *swig_obj[1] ;
15520
15521 if (!args) SWIG_fail;
15522 swig_obj[0] = args;
15523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15524 if (!SWIG_IsOK(res1)) {
15525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15526 }
15527 arg1 = reinterpret_cast< wxImage * >(argp1);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = result;
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj = 0;
15543 wxImage *arg1 = (wxImage *) 0 ;
15544 buffer arg2 ;
15545 int arg3 ;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 PyObject * obj0 = 0 ;
15549 PyObject * obj1 = 0 ;
15550 char * kwnames[] = {
15551 (char *) "self",(char *) "data", NULL
15552 };
15553
15554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15556 if (!SWIG_IsOK(res1)) {
15557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15558 }
15559 arg1 = reinterpret_cast< wxImage * >(argp1);
15560 {
15561 if (obj1 != Py_None) {
15562 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15563 }
15564 }
15565 {
15566 PyThreadState* __tstate = wxPyBeginAllowThreads();
15567 wxImage_SetDataBuffer(arg1,arg2,arg3);
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 resultobj = SWIG_Py_Void();
15572 return resultobj;
15573 fail:
15574 return NULL;
15575 }
15576
15577
15578 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15579 PyObject *resultobj = 0;
15580 wxImage *arg1 = (wxImage *) 0 ;
15581 PyObject *result = 0 ;
15582 void *argp1 = 0 ;
15583 int res1 = 0 ;
15584 PyObject *swig_obj[1] ;
15585
15586 if (!args) SWIG_fail;
15587 swig_obj[0] = args;
15588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15589 if (!SWIG_IsOK(res1)) {
15590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15591 }
15592 arg1 = reinterpret_cast< wxImage * >(argp1);
15593 {
15594 PyThreadState* __tstate = wxPyBeginAllowThreads();
15595 result = (PyObject *)wxImage_GetAlphaData(arg1);
15596 wxPyEndAllowThreads(__tstate);
15597 if (PyErr_Occurred()) SWIG_fail;
15598 }
15599 resultobj = result;
15600 return resultobj;
15601 fail:
15602 return NULL;
15603 }
15604
15605
15606 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15607 PyObject *resultobj = 0;
15608 wxImage *arg1 = (wxImage *) 0 ;
15609 buffer arg2 ;
15610 int arg3 ;
15611 void *argp1 = 0 ;
15612 int res1 = 0 ;
15613 PyObject * obj0 = 0 ;
15614 PyObject * obj1 = 0 ;
15615 char * kwnames[] = {
15616 (char *) "self",(char *) "alpha", NULL
15617 };
15618
15619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15621 if (!SWIG_IsOK(res1)) {
15622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15623 }
15624 arg1 = reinterpret_cast< wxImage * >(argp1);
15625 {
15626 if (obj1 != Py_None) {
15627 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15628 }
15629 }
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 wxImage_SetAlphaData(arg1,arg2,arg3);
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 resultobj = SWIG_Py_Void();
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15644 PyObject *resultobj = 0;
15645 wxImage *arg1 = (wxImage *) 0 ;
15646 PyObject *result = 0 ;
15647 void *argp1 = 0 ;
15648 int res1 = 0 ;
15649 PyObject *swig_obj[1] ;
15650
15651 if (!args) SWIG_fail;
15652 swig_obj[0] = args;
15653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15654 if (!SWIG_IsOK(res1)) {
15655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15656 }
15657 arg1 = reinterpret_cast< wxImage * >(argp1);
15658 {
15659 PyThreadState* __tstate = wxPyBeginAllowThreads();
15660 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 resultobj = result;
15665 return resultobj;
15666 fail:
15667 return NULL;
15668 }
15669
15670
15671 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15672 PyObject *resultobj = 0;
15673 wxImage *arg1 = (wxImage *) 0 ;
15674 buffer arg2 ;
15675 int arg3 ;
15676 void *argp1 = 0 ;
15677 int res1 = 0 ;
15678 PyObject * obj0 = 0 ;
15679 PyObject * obj1 = 0 ;
15680 char * kwnames[] = {
15681 (char *) "self",(char *) "alpha", NULL
15682 };
15683
15684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15686 if (!SWIG_IsOK(res1)) {
15687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15688 }
15689 arg1 = reinterpret_cast< wxImage * >(argp1);
15690 {
15691 if (obj1 != Py_None) {
15692 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15693 }
15694 }
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 resultobj = SWIG_Py_Void();
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj = 0;
15710 wxImage *arg1 = (wxImage *) 0 ;
15711 byte arg2 ;
15712 byte arg3 ;
15713 byte arg4 ;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 unsigned char val2 ;
15717 int ecode2 = 0 ;
15718 unsigned char val3 ;
15719 int ecode3 = 0 ;
15720 unsigned char val4 ;
15721 int ecode4 = 0 ;
15722 PyObject * obj0 = 0 ;
15723 PyObject * obj1 = 0 ;
15724 PyObject * obj2 = 0 ;
15725 PyObject * obj3 = 0 ;
15726 char * kwnames[] = {
15727 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15728 };
15729
15730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15732 if (!SWIG_IsOK(res1)) {
15733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15734 }
15735 arg1 = reinterpret_cast< wxImage * >(argp1);
15736 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15737 if (!SWIG_IsOK(ecode2)) {
15738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15739 }
15740 arg2 = static_cast< byte >(val2);
15741 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15742 if (!SWIG_IsOK(ecode3)) {
15743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15744 }
15745 arg3 = static_cast< byte >(val3);
15746 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15747 if (!SWIG_IsOK(ecode4)) {
15748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15749 }
15750 arg4 = static_cast< byte >(val4);
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 (arg1)->SetMaskColour(arg2,arg3,arg4);
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 resultobj = SWIG_Py_Void();
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15765 PyObject *resultobj = 0;
15766 wxImage *arg1 = (wxImage *) 0 ;
15767 byte *arg2 = (byte *) 0 ;
15768 byte *arg3 = (byte *) 0 ;
15769 byte *arg4 = (byte *) 0 ;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 byte temp2 ;
15773 int res2 = SWIG_TMPOBJ ;
15774 byte temp3 ;
15775 int res3 = SWIG_TMPOBJ ;
15776 byte temp4 ;
15777 int res4 = SWIG_TMPOBJ ;
15778 PyObject *swig_obj[1] ;
15779
15780 arg2 = &temp2;
15781 arg3 = &temp3;
15782 arg4 = &temp4;
15783 if (!args) SWIG_fail;
15784 swig_obj[0] = args;
15785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15786 if (!SWIG_IsOK(res1)) {
15787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15788 }
15789 arg1 = reinterpret_cast< wxImage * >(argp1);
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 resultobj = SWIG_Py_Void();
15797 if (SWIG_IsTmpObj(res2)) {
15798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15799 } else {
15800 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15802 }
15803 if (SWIG_IsTmpObj(res3)) {
15804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15805 } else {
15806 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15808 }
15809 if (SWIG_IsTmpObj(res4)) {
15810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15811 } else {
15812 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15814 }
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxImage *arg1 = (wxImage *) 0 ;
15824 byte result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15834 }
15835 arg1 = reinterpret_cast< wxImage * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (byte)(arg1)->GetMaskRed();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxImage *arg1 = (wxImage *) 0 ;
15852 byte result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15862 }
15863 arg1 = reinterpret_cast< wxImage * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (byte)(arg1)->GetMaskGreen();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxImage *arg1 = (wxImage *) 0 ;
15880 byte result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15890 }
15891 arg1 = reinterpret_cast< wxImage * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (byte)(arg1)->GetMaskBlue();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj = 0;
15907 wxImage *arg1 = (wxImage *) 0 ;
15908 bool arg2 = (bool) true ;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 bool val2 ;
15912 int ecode2 = 0 ;
15913 PyObject * obj0 = 0 ;
15914 PyObject * obj1 = 0 ;
15915 char * kwnames[] = {
15916 (char *) "self",(char *) "mask", NULL
15917 };
15918
15919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15921 if (!SWIG_IsOK(res1)) {
15922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15923 }
15924 arg1 = reinterpret_cast< wxImage * >(argp1);
15925 if (obj1) {
15926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15927 if (!SWIG_IsOK(ecode2)) {
15928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15929 }
15930 arg2 = static_cast< bool >(val2);
15931 }
15932 {
15933 PyThreadState* __tstate = wxPyBeginAllowThreads();
15934 (arg1)->SetMask(arg2);
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 resultobj = SWIG_Py_Void();
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15946 PyObject *resultobj = 0;
15947 wxImage *arg1 = (wxImage *) 0 ;
15948 bool result;
15949 void *argp1 = 0 ;
15950 int res1 = 0 ;
15951 PyObject *swig_obj[1] ;
15952
15953 if (!args) SWIG_fail;
15954 swig_obj[0] = args;
15955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15956 if (!SWIG_IsOK(res1)) {
15957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15958 }
15959 arg1 = reinterpret_cast< wxImage * >(argp1);
15960 {
15961 PyThreadState* __tstate = wxPyBeginAllowThreads();
15962 result = (bool)(arg1)->HasMask();
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15968 }
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj = 0;
15977 wxImage *arg1 = (wxImage *) 0 ;
15978 double arg2 ;
15979 wxPoint *arg3 = 0 ;
15980 bool arg4 = (bool) true ;
15981 wxPoint *arg5 = (wxPoint *) NULL ;
15982 SwigValueWrapper<wxImage > result;
15983 void *argp1 = 0 ;
15984 int res1 = 0 ;
15985 double val2 ;
15986 int ecode2 = 0 ;
15987 wxPoint temp3 ;
15988 bool val4 ;
15989 int ecode4 = 0 ;
15990 void *argp5 = 0 ;
15991 int res5 = 0 ;
15992 PyObject * obj0 = 0 ;
15993 PyObject * obj1 = 0 ;
15994 PyObject * obj2 = 0 ;
15995 PyObject * obj3 = 0 ;
15996 PyObject * obj4 = 0 ;
15997 char * kwnames[] = {
15998 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15999 };
16000
16001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16003 if (!SWIG_IsOK(res1)) {
16004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16005 }
16006 arg1 = reinterpret_cast< wxImage * >(argp1);
16007 ecode2 = SWIG_AsVal_double(obj1, &val2);
16008 if (!SWIG_IsOK(ecode2)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16010 }
16011 arg2 = static_cast< double >(val2);
16012 {
16013 arg3 = &temp3;
16014 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16015 }
16016 if (obj3) {
16017 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16018 if (!SWIG_IsOK(ecode4)) {
16019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16020 }
16021 arg4 = static_cast< bool >(val4);
16022 }
16023 if (obj4) {
16024 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16025 if (!SWIG_IsOK(res5)) {
16026 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16027 }
16028 arg5 = reinterpret_cast< wxPoint * >(argp5);
16029 }
16030 {
16031 PyThreadState* __tstate = wxPyBeginAllowThreads();
16032 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16033 wxPyEndAllowThreads(__tstate);
16034 if (PyErr_Occurred()) SWIG_fail;
16035 }
16036 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16037 return resultobj;
16038 fail:
16039 return NULL;
16040 }
16041
16042
16043 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16044 PyObject *resultobj = 0;
16045 wxImage *arg1 = (wxImage *) 0 ;
16046 bool arg2 = (bool) true ;
16047 SwigValueWrapper<wxImage > result;
16048 void *argp1 = 0 ;
16049 int res1 = 0 ;
16050 bool val2 ;
16051 int ecode2 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 char * kwnames[] = {
16055 (char *) "self",(char *) "clockwise", NULL
16056 };
16057
16058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16060 if (!SWIG_IsOK(res1)) {
16061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16062 }
16063 arg1 = reinterpret_cast< wxImage * >(argp1);
16064 if (obj1) {
16065 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16066 if (!SWIG_IsOK(ecode2)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16068 }
16069 arg2 = static_cast< bool >(val2);
16070 }
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (arg1)->Rotate90(arg2);
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj = 0;
16086 wxImage *arg1 = (wxImage *) 0 ;
16087 bool arg2 = (bool) true ;
16088 SwigValueWrapper<wxImage > result;
16089 void *argp1 = 0 ;
16090 int res1 = 0 ;
16091 bool val2 ;
16092 int ecode2 = 0 ;
16093 PyObject * obj0 = 0 ;
16094 PyObject * obj1 = 0 ;
16095 char * kwnames[] = {
16096 (char *) "self",(char *) "horizontally", NULL
16097 };
16098
16099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16101 if (!SWIG_IsOK(res1)) {
16102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16103 }
16104 arg1 = reinterpret_cast< wxImage * >(argp1);
16105 if (obj1) {
16106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16107 if (!SWIG_IsOK(ecode2)) {
16108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16109 }
16110 arg2 = static_cast< bool >(val2);
16111 }
16112 {
16113 PyThreadState* __tstate = wxPyBeginAllowThreads();
16114 result = (arg1)->Mirror(arg2);
16115 wxPyEndAllowThreads(__tstate);
16116 if (PyErr_Occurred()) SWIG_fail;
16117 }
16118 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16119 return resultobj;
16120 fail:
16121 return NULL;
16122 }
16123
16124
16125 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj = 0;
16127 wxImage *arg1 = (wxImage *) 0 ;
16128 byte arg2 ;
16129 byte arg3 ;
16130 byte arg4 ;
16131 byte arg5 ;
16132 byte arg6 ;
16133 byte arg7 ;
16134 void *argp1 = 0 ;
16135 int res1 = 0 ;
16136 unsigned char val2 ;
16137 int ecode2 = 0 ;
16138 unsigned char val3 ;
16139 int ecode3 = 0 ;
16140 unsigned char val4 ;
16141 int ecode4 = 0 ;
16142 unsigned char val5 ;
16143 int ecode5 = 0 ;
16144 unsigned char val6 ;
16145 int ecode6 = 0 ;
16146 unsigned char val7 ;
16147 int ecode7 = 0 ;
16148 PyObject * obj0 = 0 ;
16149 PyObject * obj1 = 0 ;
16150 PyObject * obj2 = 0 ;
16151 PyObject * obj3 = 0 ;
16152 PyObject * obj4 = 0 ;
16153 PyObject * obj5 = 0 ;
16154 PyObject * obj6 = 0 ;
16155 char * kwnames[] = {
16156 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16157 };
16158
16159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16163 }
16164 arg1 = reinterpret_cast< wxImage * >(argp1);
16165 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16166 if (!SWIG_IsOK(ecode2)) {
16167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16168 }
16169 arg2 = static_cast< byte >(val2);
16170 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16171 if (!SWIG_IsOK(ecode3)) {
16172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16173 }
16174 arg3 = static_cast< byte >(val3);
16175 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16176 if (!SWIG_IsOK(ecode4)) {
16177 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16178 }
16179 arg4 = static_cast< byte >(val4);
16180 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16181 if (!SWIG_IsOK(ecode5)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16183 }
16184 arg5 = static_cast< byte >(val5);
16185 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16186 if (!SWIG_IsOK(ecode6)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16188 }
16189 arg6 = static_cast< byte >(val6);
16190 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16191 if (!SWIG_IsOK(ecode7)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16193 }
16194 arg7 = static_cast< byte >(val7);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_Py_Void();
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxImage *arg1 = (wxImage *) 0 ;
16211 double arg2 = (double) 0.299 ;
16212 double arg3 = (double) 0.587 ;
16213 double arg4 = (double) 0.114 ;
16214 SwigValueWrapper<wxImage > result;
16215 void *argp1 = 0 ;
16216 int res1 = 0 ;
16217 double val2 ;
16218 int ecode2 = 0 ;
16219 double val3 ;
16220 int ecode3 = 0 ;
16221 double val4 ;
16222 int ecode4 = 0 ;
16223 PyObject * obj0 = 0 ;
16224 PyObject * obj1 = 0 ;
16225 PyObject * obj2 = 0 ;
16226 PyObject * obj3 = 0 ;
16227 char * kwnames[] = {
16228 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16229 };
16230
16231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16233 if (!SWIG_IsOK(res1)) {
16234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16235 }
16236 arg1 = reinterpret_cast< wxImage * >(argp1);
16237 if (obj1) {
16238 ecode2 = SWIG_AsVal_double(obj1, &val2);
16239 if (!SWIG_IsOK(ecode2)) {
16240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16241 }
16242 arg2 = static_cast< double >(val2);
16243 }
16244 if (obj2) {
16245 ecode3 = SWIG_AsVal_double(obj2, &val3);
16246 if (!SWIG_IsOK(ecode3)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16248 }
16249 arg3 = static_cast< double >(val3);
16250 }
16251 if (obj3) {
16252 ecode4 = SWIG_AsVal_double(obj3, &val4);
16253 if (!SWIG_IsOK(ecode4)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16255 }
16256 arg4 = static_cast< double >(val4);
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 byte arg2 ;
16275 byte arg3 ;
16276 byte arg4 ;
16277 SwigValueWrapper<wxImage > result;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 unsigned char val2 ;
16281 int ecode2 = 0 ;
16282 unsigned char val3 ;
16283 int ecode3 = 0 ;
16284 unsigned char val4 ;
16285 int ecode4 = 0 ;
16286 PyObject * obj0 = 0 ;
16287 PyObject * obj1 = 0 ;
16288 PyObject * obj2 = 0 ;
16289 PyObject * obj3 = 0 ;
16290 char * kwnames[] = {
16291 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16292 };
16293
16294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16296 if (!SWIG_IsOK(res1)) {
16297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16298 }
16299 arg1 = reinterpret_cast< wxImage * >(argp1);
16300 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16301 if (!SWIG_IsOK(ecode2)) {
16302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16303 }
16304 arg2 = static_cast< byte >(val2);
16305 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16306 if (!SWIG_IsOK(ecode3)) {
16307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16308 }
16309 arg3 = static_cast< byte >(val3);
16310 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16311 if (!SWIG_IsOK(ecode4)) {
16312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16313 }
16314 arg4 = static_cast< byte >(val4);
16315 {
16316 PyThreadState* __tstate = wxPyBeginAllowThreads();
16317 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16318 wxPyEndAllowThreads(__tstate);
16319 if (PyErr_Occurred()) SWIG_fail;
16320 }
16321 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj = 0;
16330 wxImage *arg1 = (wxImage *) 0 ;
16331 wxString *arg2 = 0 ;
16332 wxString *arg3 = 0 ;
16333 void *argp1 = 0 ;
16334 int res1 = 0 ;
16335 bool temp2 = false ;
16336 bool temp3 = false ;
16337 PyObject * obj0 = 0 ;
16338 PyObject * obj1 = 0 ;
16339 PyObject * obj2 = 0 ;
16340 char * kwnames[] = {
16341 (char *) "self",(char *) "name",(char *) "value", NULL
16342 };
16343
16344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16346 if (!SWIG_IsOK(res1)) {
16347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16348 }
16349 arg1 = reinterpret_cast< wxImage * >(argp1);
16350 {
16351 arg2 = wxString_in_helper(obj1);
16352 if (arg2 == NULL) SWIG_fail;
16353 temp2 = true;
16354 }
16355 {
16356 arg3 = wxString_in_helper(obj2);
16357 if (arg3 == NULL) SWIG_fail;
16358 temp3 = true;
16359 }
16360 {
16361 PyThreadState* __tstate = wxPyBeginAllowThreads();
16362 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 resultobj = SWIG_Py_Void();
16367 {
16368 if (temp2)
16369 delete arg2;
16370 }
16371 {
16372 if (temp3)
16373 delete arg3;
16374 }
16375 return resultobj;
16376 fail:
16377 {
16378 if (temp2)
16379 delete arg2;
16380 }
16381 {
16382 if (temp3)
16383 delete arg3;
16384 }
16385 return NULL;
16386 }
16387
16388
16389 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16390 PyObject *resultobj = 0;
16391 wxImage *arg1 = (wxImage *) 0 ;
16392 wxString *arg2 = 0 ;
16393 int arg3 ;
16394 void *argp1 = 0 ;
16395 int res1 = 0 ;
16396 bool temp2 = false ;
16397 int val3 ;
16398 int ecode3 = 0 ;
16399 PyObject * obj0 = 0 ;
16400 PyObject * obj1 = 0 ;
16401 PyObject * obj2 = 0 ;
16402 char * kwnames[] = {
16403 (char *) "self",(char *) "name",(char *) "value", NULL
16404 };
16405
16406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16408 if (!SWIG_IsOK(res1)) {
16409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16410 }
16411 arg1 = reinterpret_cast< wxImage * >(argp1);
16412 {
16413 arg2 = wxString_in_helper(obj1);
16414 if (arg2 == NULL) SWIG_fail;
16415 temp2 = true;
16416 }
16417 ecode3 = SWIG_AsVal_int(obj2, &val3);
16418 if (!SWIG_IsOK(ecode3)) {
16419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16420 }
16421 arg3 = static_cast< int >(val3);
16422 {
16423 PyThreadState* __tstate = wxPyBeginAllowThreads();
16424 (arg1)->SetOption((wxString const &)*arg2,arg3);
16425 wxPyEndAllowThreads(__tstate);
16426 if (PyErr_Occurred()) SWIG_fail;
16427 }
16428 resultobj = SWIG_Py_Void();
16429 {
16430 if (temp2)
16431 delete arg2;
16432 }
16433 return resultobj;
16434 fail:
16435 {
16436 if (temp2)
16437 delete arg2;
16438 }
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 wxString *arg2 = 0 ;
16447 wxString result;
16448 void *argp1 = 0 ;
16449 int res1 = 0 ;
16450 bool temp2 = false ;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 char * kwnames[] = {
16454 (char *) "self",(char *) "name", NULL
16455 };
16456
16457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16459 if (!SWIG_IsOK(res1)) {
16460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16461 }
16462 arg1 = reinterpret_cast< wxImage * >(argp1);
16463 {
16464 arg2 = wxString_in_helper(obj1);
16465 if (arg2 == NULL) SWIG_fail;
16466 temp2 = true;
16467 }
16468 {
16469 PyThreadState* __tstate = wxPyBeginAllowThreads();
16470 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16471 wxPyEndAllowThreads(__tstate);
16472 if (PyErr_Occurred()) SWIG_fail;
16473 }
16474 {
16475 #if wxUSE_UNICODE
16476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16477 #else
16478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16479 #endif
16480 }
16481 {
16482 if (temp2)
16483 delete arg2;
16484 }
16485 return resultobj;
16486 fail:
16487 {
16488 if (temp2)
16489 delete arg2;
16490 }
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16496 PyObject *resultobj = 0;
16497 wxImage *arg1 = (wxImage *) 0 ;
16498 wxString *arg2 = 0 ;
16499 int result;
16500 void *argp1 = 0 ;
16501 int res1 = 0 ;
16502 bool temp2 = false ;
16503 PyObject * obj0 = 0 ;
16504 PyObject * obj1 = 0 ;
16505 char * kwnames[] = {
16506 (char *) "self",(char *) "name", NULL
16507 };
16508
16509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16511 if (!SWIG_IsOK(res1)) {
16512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16513 }
16514 arg1 = reinterpret_cast< wxImage * >(argp1);
16515 {
16516 arg2 = wxString_in_helper(obj1);
16517 if (arg2 == NULL) SWIG_fail;
16518 temp2 = true;
16519 }
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 resultobj = SWIG_From_int(static_cast< int >(result));
16527 {
16528 if (temp2)
16529 delete arg2;
16530 }
16531 return resultobj;
16532 fail:
16533 {
16534 if (temp2)
16535 delete arg2;
16536 }
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxImage *arg1 = (wxImage *) 0 ;
16544 wxString *arg2 = 0 ;
16545 bool result;
16546 void *argp1 = 0 ;
16547 int res1 = 0 ;
16548 bool temp2 = false ;
16549 PyObject * obj0 = 0 ;
16550 PyObject * obj1 = 0 ;
16551 char * kwnames[] = {
16552 (char *) "self",(char *) "name", NULL
16553 };
16554
16555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16557 if (!SWIG_IsOK(res1)) {
16558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16559 }
16560 arg1 = reinterpret_cast< wxImage * >(argp1);
16561 {
16562 arg2 = wxString_in_helper(obj1);
16563 if (arg2 == NULL) SWIG_fail;
16564 temp2 = true;
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16569 wxPyEndAllowThreads(__tstate);
16570 if (PyErr_Occurred()) SWIG_fail;
16571 }
16572 {
16573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16574 }
16575 {
16576 if (temp2)
16577 delete arg2;
16578 }
16579 return resultobj;
16580 fail:
16581 {
16582 if (temp2)
16583 delete arg2;
16584 }
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxImage *arg1 = (wxImage *) 0 ;
16592 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16593 unsigned long result;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 unsigned long val2 ;
16597 int ecode2 = 0 ;
16598 PyObject * obj0 = 0 ;
16599 PyObject * obj1 = 0 ;
16600 char * kwnames[] = {
16601 (char *) "self",(char *) "stopafter", NULL
16602 };
16603
16604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16606 if (!SWIG_IsOK(res1)) {
16607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16608 }
16609 arg1 = reinterpret_cast< wxImage * >(argp1);
16610 if (obj1) {
16611 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16612 if (!SWIG_IsOK(ecode2)) {
16613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16614 }
16615 arg2 = static_cast< unsigned long >(val2);
16616 }
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 result = (unsigned long)(arg1)->CountColours(arg2);
16620 wxPyEndAllowThreads(__tstate);
16621 if (PyErr_Occurred()) SWIG_fail;
16622 }
16623 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16624 return resultobj;
16625 fail:
16626 return NULL;
16627 }
16628
16629
16630 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16631 PyObject *resultobj = 0;
16632 wxImage *arg1 = (wxImage *) 0 ;
16633 wxImageHistogram *arg2 = 0 ;
16634 unsigned long result;
16635 void *argp1 = 0 ;
16636 int res1 = 0 ;
16637 void *argp2 = 0 ;
16638 int res2 = 0 ;
16639 PyObject * obj0 = 0 ;
16640 PyObject * obj1 = 0 ;
16641 char * kwnames[] = {
16642 (char *) "self",(char *) "h", NULL
16643 };
16644
16645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16647 if (!SWIG_IsOK(res1)) {
16648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16649 }
16650 arg1 = reinterpret_cast< wxImage * >(argp1);
16651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16652 if (!SWIG_IsOK(res2)) {
16653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16654 }
16655 if (!argp2) {
16656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16657 }
16658 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16662 wxPyEndAllowThreads(__tstate);
16663 if (PyErr_Occurred()) SWIG_fail;
16664 }
16665 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj = 0;
16674 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16675 void *argp1 = 0 ;
16676 int res1 = 0 ;
16677 PyObject * obj0 = 0 ;
16678 char * kwnames[] = {
16679 (char *) "handler", NULL
16680 };
16681
16682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16684 if (!SWIG_IsOK(res1)) {
16685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16686 }
16687 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16688 {
16689 PyThreadState* __tstate = wxPyBeginAllowThreads();
16690 wxImage::AddHandler(arg1);
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 resultobj = SWIG_Py_Void();
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj = 0;
16703 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16704 void *argp1 = 0 ;
16705 int res1 = 0 ;
16706 PyObject * obj0 = 0 ;
16707 char * kwnames[] = {
16708 (char *) "handler", NULL
16709 };
16710
16711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16713 if (!SWIG_IsOK(res1)) {
16714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16715 }
16716 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 wxImage::InsertHandler(arg1);
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = SWIG_Py_Void();
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj = 0;
16732 wxString *arg1 = 0 ;
16733 bool result;
16734 bool temp1 = false ;
16735 PyObject * obj0 = 0 ;
16736 char * kwnames[] = {
16737 (char *) "name", NULL
16738 };
16739
16740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16741 {
16742 arg1 = wxString_in_helper(obj0);
16743 if (arg1 == NULL) SWIG_fail;
16744 temp1 = true;
16745 }
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16749 wxPyEndAllowThreads(__tstate);
16750 if (PyErr_Occurred()) SWIG_fail;
16751 }
16752 {
16753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16754 }
16755 {
16756 if (temp1)
16757 delete arg1;
16758 }
16759 return resultobj;
16760 fail:
16761 {
16762 if (temp1)
16763 delete arg1;
16764 }
16765 return NULL;
16766 }
16767
16768
16769 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16770 PyObject *resultobj = 0;
16771 PyObject *result = 0 ;
16772
16773 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (PyObject *)wxImage_GetHandlers();
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 resultobj = result;
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16788 PyObject *resultobj = 0;
16789 wxString result;
16790
16791 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = wxImage::GetImageExtWildcard();
16795 wxPyEndAllowThreads(__tstate);
16796 if (PyErr_Occurred()) SWIG_fail;
16797 }
16798 {
16799 #if wxUSE_UNICODE
16800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16801 #else
16802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16803 #endif
16804 }
16805 return resultobj;
16806 fail:
16807 return NULL;
16808 }
16809
16810
16811 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16812 PyObject *resultobj = 0;
16813 wxImage *arg1 = (wxImage *) 0 ;
16814 int arg2 = (int) -1 ;
16815 wxBitmap result;
16816 void *argp1 = 0 ;
16817 int res1 = 0 ;
16818 int val2 ;
16819 int ecode2 = 0 ;
16820 PyObject * obj0 = 0 ;
16821 PyObject * obj1 = 0 ;
16822 char * kwnames[] = {
16823 (char *) "self",(char *) "depth", NULL
16824 };
16825
16826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16828 if (!SWIG_IsOK(res1)) {
16829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16830 }
16831 arg1 = reinterpret_cast< wxImage * >(argp1);
16832 if (obj1) {
16833 ecode2 = SWIG_AsVal_int(obj1, &val2);
16834 if (!SWIG_IsOK(ecode2)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16836 }
16837 arg2 = static_cast< int >(val2);
16838 }
16839 {
16840 if (!wxPyCheckForApp()) SWIG_fail;
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = wxImage_ConvertToBitmap(arg1,arg2);
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16847 return resultobj;
16848 fail:
16849 return NULL;
16850 }
16851
16852
16853 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16854 PyObject *resultobj = 0;
16855 wxImage *arg1 = (wxImage *) 0 ;
16856 byte arg2 ;
16857 byte arg3 ;
16858 byte arg4 ;
16859 wxBitmap result;
16860 void *argp1 = 0 ;
16861 int res1 = 0 ;
16862 unsigned char val2 ;
16863 int ecode2 = 0 ;
16864 unsigned char val3 ;
16865 int ecode3 = 0 ;
16866 unsigned char val4 ;
16867 int ecode4 = 0 ;
16868 PyObject * obj0 = 0 ;
16869 PyObject * obj1 = 0 ;
16870 PyObject * obj2 = 0 ;
16871 PyObject * obj3 = 0 ;
16872 char * kwnames[] = {
16873 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16874 };
16875
16876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16880 }
16881 arg1 = reinterpret_cast< wxImage * >(argp1);
16882 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16883 if (!SWIG_IsOK(ecode2)) {
16884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16885 }
16886 arg2 = static_cast< byte >(val2);
16887 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16888 if (!SWIG_IsOK(ecode3)) {
16889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16890 }
16891 arg3 = static_cast< byte >(val3);
16892 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16893 if (!SWIG_IsOK(ecode4)) {
16894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16895 }
16896 arg4 = static_cast< byte >(val4);
16897 {
16898 if (!wxPyCheckForApp()) SWIG_fail;
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj = 0;
16913 wxImage *arg1 = (wxImage *) 0 ;
16914 double arg2 ;
16915 void *argp1 = 0 ;
16916 int res1 = 0 ;
16917 double val2 ;
16918 int ecode2 = 0 ;
16919 PyObject * obj0 = 0 ;
16920 PyObject * obj1 = 0 ;
16921 char * kwnames[] = {
16922 (char *) "self",(char *) "angle", NULL
16923 };
16924
16925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16927 if (!SWIG_IsOK(res1)) {
16928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16929 }
16930 arg1 = reinterpret_cast< wxImage * >(argp1);
16931 ecode2 = SWIG_AsVal_double(obj1, &val2);
16932 if (!SWIG_IsOK(ecode2)) {
16933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16934 }
16935 arg2 = static_cast< double >(val2);
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 (arg1)->RotateHue(arg2);
16939 wxPyEndAllowThreads(__tstate);
16940 if (PyErr_Occurred()) SWIG_fail;
16941 }
16942 resultobj = SWIG_Py_Void();
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16950 PyObject *resultobj = 0;
16951 wxImage_RGBValue arg1 ;
16952 wxImage_HSVValue result;
16953 void *argp1 ;
16954 int res1 = 0 ;
16955 PyObject * obj0 = 0 ;
16956 char * kwnames[] = {
16957 (char *) "rgb", NULL
16958 };
16959
16960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16961 {
16962 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16963 if (!SWIG_IsOK(res1)) {
16964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16965 }
16966 if (!argp1) {
16967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16968 } else {
16969 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16970 arg1 = *temp;
16971 if (SWIG_IsNewObj(res1)) delete temp;
16972 }
16973 }
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = wxImage::RGBtoHSV(arg1);
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj = 0;
16989 wxImage_HSVValue arg1 ;
16990 wxImage_RGBValue result;
16991 void *argp1 ;
16992 int res1 = 0 ;
16993 PyObject * obj0 = 0 ;
16994 char * kwnames[] = {
16995 (char *) "hsv", NULL
16996 };
16997
16998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16999 {
17000 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17001 if (!SWIG_IsOK(res1)) {
17002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17003 }
17004 if (!argp1) {
17005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17006 } else {
17007 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17008 arg1 = *temp;
17009 if (SWIG_IsNewObj(res1)) delete temp;
17010 }
17011 }
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 result = wxImage::HSVtoRGB(arg1);
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17026 PyObject *obj;
17027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17028 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17029 return SWIG_Py_Void();
17030 }
17031
17032 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17033 return SWIG_Python_InitShadowInstance(args);
17034 }
17035
17036 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17037 PyObject *resultobj = 0;
17038 int arg1 ;
17039 int arg2 ;
17040 buffer arg3 ;
17041 int arg4 ;
17042 buffer arg5 = (buffer) NULL ;
17043 int arg6 = (int) 0 ;
17044 wxImage *result = 0 ;
17045 int val1 ;
17046 int ecode1 = 0 ;
17047 int val2 ;
17048 int ecode2 = 0 ;
17049 PyObject * obj0 = 0 ;
17050 PyObject * obj1 = 0 ;
17051 PyObject * obj2 = 0 ;
17052 PyObject * obj3 = 0 ;
17053 char * kwnames[] = {
17054 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17055 };
17056
17057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17058 ecode1 = SWIG_AsVal_int(obj0, &val1);
17059 if (!SWIG_IsOK(ecode1)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17061 }
17062 arg1 = static_cast< int >(val1);
17063 ecode2 = SWIG_AsVal_int(obj1, &val2);
17064 if (!SWIG_IsOK(ecode2)) {
17065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17066 }
17067 arg2 = static_cast< int >(val2);
17068 {
17069 if (obj2 != Py_None) {
17070 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
17071 }
17072 }
17073 if (obj3) {
17074 {
17075 if (obj3 != Py_None) {
17076 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
17077 }
17078 }
17079 }
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 {
17087 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17088 }
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 SWIGINTERN int NullImage_set(PyObject *) {
17096 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17097 return 1;
17098 }
17099
17100
17101 SWIGINTERN PyObject *NullImage_get(void) {
17102 PyObject *pyobj = 0;
17103
17104 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17105 return pyobj;
17106 }
17107
17108
17109 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17110 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17111 return 1;
17112 }
17113
17114
17115 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17116 PyObject *pyobj = 0;
17117
17118 {
17119 #if wxUSE_UNICODE
17120 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17121 #else
17122 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17123 #endif
17124 }
17125 return pyobj;
17126 }
17127
17128
17129 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17130 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17131 return 1;
17132 }
17133
17134
17135 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17136 PyObject *pyobj = 0;
17137
17138 {
17139 #if wxUSE_UNICODE
17140 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17141 #else
17142 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17143 #endif
17144 }
17145 return pyobj;
17146 }
17147
17148
17149 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17150 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17151 return 1;
17152 }
17153
17154
17155 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17156 PyObject *pyobj = 0;
17157
17158 {
17159 #if wxUSE_UNICODE
17160 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17161 #else
17162 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17163 #endif
17164 }
17165 return pyobj;
17166 }
17167
17168
17169 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17170 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17171 return 1;
17172 }
17173
17174
17175 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17176 PyObject *pyobj = 0;
17177
17178 {
17179 #if wxUSE_UNICODE
17180 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17181 #else
17182 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17183 #endif
17184 }
17185 return pyobj;
17186 }
17187
17188
17189 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17190 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17191 return 1;
17192 }
17193
17194
17195 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17196 PyObject *pyobj = 0;
17197
17198 {
17199 #if wxUSE_UNICODE
17200 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17201 #else
17202 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17203 #endif
17204 }
17205 return pyobj;
17206 }
17207
17208
17209 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17210 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17211 return 1;
17212 }
17213
17214
17215 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17216 PyObject *pyobj = 0;
17217
17218 {
17219 #if wxUSE_UNICODE
17220 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17221 #else
17222 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17223 #endif
17224 }
17225 return pyobj;
17226 }
17227
17228
17229 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17230 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17231 return 1;
17232 }
17233
17234
17235 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17236 PyObject *pyobj = 0;
17237
17238 {
17239 #if wxUSE_UNICODE
17240 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17241 #else
17242 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17243 #endif
17244 }
17245 return pyobj;
17246 }
17247
17248
17249 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17250 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17251 return 1;
17252 }
17253
17254
17255 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17256 PyObject *pyobj = 0;
17257
17258 {
17259 #if wxUSE_UNICODE
17260 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17261 #else
17262 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17263 #endif
17264 }
17265 return pyobj;
17266 }
17267
17268
17269 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17270 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17271 return 1;
17272 }
17273
17274
17275 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17276 PyObject *pyobj = 0;
17277
17278 {
17279 #if wxUSE_UNICODE
17280 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17281 #else
17282 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17283 #endif
17284 }
17285 return pyobj;
17286 }
17287
17288
17289 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17290 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17291 return 1;
17292 }
17293
17294
17295 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17296 PyObject *pyobj = 0;
17297
17298 {
17299 #if wxUSE_UNICODE
17300 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17301 #else
17302 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17303 #endif
17304 }
17305 return pyobj;
17306 }
17307
17308
17309 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17310 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17311 return 1;
17312 }
17313
17314
17315 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17316 PyObject *pyobj = 0;
17317
17318 {
17319 #if wxUSE_UNICODE
17320 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17321 #else
17322 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17323 #endif
17324 }
17325 return pyobj;
17326 }
17327
17328
17329 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17330 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17331 return 1;
17332 }
17333
17334
17335 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17336 PyObject *pyobj = 0;
17337
17338 {
17339 #if wxUSE_UNICODE
17340 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17341 #else
17342 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17343 #endif
17344 }
17345 return pyobj;
17346 }
17347
17348
17349 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17350 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17351 return 1;
17352 }
17353
17354
17355 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17356 PyObject *pyobj = 0;
17357
17358 {
17359 #if wxUSE_UNICODE
17360 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17361 #else
17362 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17363 #endif
17364 }
17365 return pyobj;
17366 }
17367
17368
17369 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17370 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17371 return 1;
17372 }
17373
17374
17375 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17376 PyObject *pyobj = 0;
17377
17378 {
17379 #if wxUSE_UNICODE
17380 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17381 #else
17382 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17383 #endif
17384 }
17385 return pyobj;
17386 }
17387
17388
17389 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17390 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17391 return 1;
17392 }
17393
17394
17395 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17396 PyObject *pyobj = 0;
17397
17398 {
17399 #if wxUSE_UNICODE
17400 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17401 #else
17402 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17403 #endif
17404 }
17405 return pyobj;
17406 }
17407
17408
17409 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 PyObject *resultobj = 0;
17411 wxBMPHandler *result = 0 ;
17412
17413 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17414 {
17415 PyThreadState* __tstate = wxPyBeginAllowThreads();
17416 result = (wxBMPHandler *)new wxBMPHandler();
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17421 return resultobj;
17422 fail:
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 PyObject *obj;
17429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17430 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17431 return SWIG_Py_Void();
17432 }
17433
17434 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17435 return SWIG_Python_InitShadowInstance(args);
17436 }
17437
17438 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 PyObject *resultobj = 0;
17440 wxICOHandler *result = 0 ;
17441
17442 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (wxICOHandler *)new wxICOHandler();
17446 wxPyEndAllowThreads(__tstate);
17447 if (PyErr_Occurred()) SWIG_fail;
17448 }
17449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17450 return resultobj;
17451 fail:
17452 return NULL;
17453 }
17454
17455
17456 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17457 PyObject *obj;
17458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17459 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17460 return SWIG_Py_Void();
17461 }
17462
17463 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17464 return SWIG_Python_InitShadowInstance(args);
17465 }
17466
17467 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 PyObject *resultobj = 0;
17469 wxCURHandler *result = 0 ;
17470
17471 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (wxCURHandler *)new wxCURHandler();
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17486 PyObject *obj;
17487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17488 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17489 return SWIG_Py_Void();
17490 }
17491
17492 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 return SWIG_Python_InitShadowInstance(args);
17494 }
17495
17496 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 PyObject *resultobj = 0;
17498 wxANIHandler *result = 0 ;
17499
17500 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (wxANIHandler *)new wxANIHandler();
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 PyObject *obj;
17516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17517 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17518 return SWIG_Py_Void();
17519 }
17520
17521 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 return SWIG_Python_InitShadowInstance(args);
17523 }
17524
17525 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *resultobj = 0;
17527 wxPNGHandler *result = 0 ;
17528
17529 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (wxPNGHandler *)new wxPNGHandler();
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17544 PyObject *obj;
17545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17547 return SWIG_Py_Void();
17548 }
17549
17550 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17551 return SWIG_Python_InitShadowInstance(args);
17552 }
17553
17554 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17555 PyObject *resultobj = 0;
17556 wxGIFHandler *result = 0 ;
17557
17558 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 result = (wxGIFHandler *)new wxGIFHandler();
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *obj;
17574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17575 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17576 return SWIG_Py_Void();
17577 }
17578
17579 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 return SWIG_Python_InitShadowInstance(args);
17581 }
17582
17583 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17584 PyObject *resultobj = 0;
17585 wxPCXHandler *result = 0 ;
17586
17587 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17588 {
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (wxPCXHandler *)new wxPCXHandler();
17591 wxPyEndAllowThreads(__tstate);
17592 if (PyErr_Occurred()) SWIG_fail;
17593 }
17594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *obj;
17603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17604 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17605 return SWIG_Py_Void();
17606 }
17607
17608 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 return SWIG_Python_InitShadowInstance(args);
17610 }
17611
17612 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17613 PyObject *resultobj = 0;
17614 wxJPEGHandler *result = 0 ;
17615
17616 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (wxJPEGHandler *)new wxJPEGHandler();
17620 wxPyEndAllowThreads(__tstate);
17621 if (PyErr_Occurred()) SWIG_fail;
17622 }
17623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17631 PyObject *obj;
17632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17633 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17634 return SWIG_Py_Void();
17635 }
17636
17637 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17638 return SWIG_Python_InitShadowInstance(args);
17639 }
17640
17641 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17642 PyObject *resultobj = 0;
17643 wxPNMHandler *result = 0 ;
17644
17645 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (wxPNMHandler *)new wxPNMHandler();
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17660 PyObject *obj;
17661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17662 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17663 return SWIG_Py_Void();
17664 }
17665
17666 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17667 return SWIG_Python_InitShadowInstance(args);
17668 }
17669
17670 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17671 PyObject *resultobj = 0;
17672 wxXPMHandler *result = 0 ;
17673
17674 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 result = (wxXPMHandler *)new wxXPMHandler();
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *obj;
17690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17691 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17692 return SWIG_Py_Void();
17693 }
17694
17695 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17696 return SWIG_Python_InitShadowInstance(args);
17697 }
17698
17699 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17700 PyObject *resultobj = 0;
17701 wxTIFFHandler *result = 0 ;
17702
17703 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17704 {
17705 PyThreadState* __tstate = wxPyBeginAllowThreads();
17706 result = (wxTIFFHandler *)new wxTIFFHandler();
17707 wxPyEndAllowThreads(__tstate);
17708 if (PyErr_Occurred()) SWIG_fail;
17709 }
17710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17711 return resultobj;
17712 fail:
17713 return NULL;
17714 }
17715
17716
17717 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17718 PyObject *obj;
17719 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17720 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17721 return SWIG_Py_Void();
17722 }
17723
17724 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17725 return SWIG_Python_InitShadowInstance(args);
17726 }
17727
17728 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17729 PyObject *resultobj = 0;
17730 wxImage *arg1 = 0 ;
17731 wxImage *arg2 = 0 ;
17732 int arg3 = (int) 236 ;
17733 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17734 bool result;
17735 void *argp1 = 0 ;
17736 int res1 = 0 ;
17737 void *argp2 = 0 ;
17738 int res2 = 0 ;
17739 int val3 ;
17740 int ecode3 = 0 ;
17741 int val4 ;
17742 int ecode4 = 0 ;
17743 PyObject * obj0 = 0 ;
17744 PyObject * obj1 = 0 ;
17745 PyObject * obj2 = 0 ;
17746 PyObject * obj3 = 0 ;
17747 char * kwnames[] = {
17748 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17749 };
17750
17751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17752 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17753 if (!SWIG_IsOK(res1)) {
17754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17755 }
17756 if (!argp1) {
17757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17758 }
17759 arg1 = reinterpret_cast< wxImage * >(argp1);
17760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17761 if (!SWIG_IsOK(res2)) {
17762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17763 }
17764 if (!argp2) {
17765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17766 }
17767 arg2 = reinterpret_cast< wxImage * >(argp2);
17768 if (obj2) {
17769 ecode3 = SWIG_AsVal_int(obj2, &val3);
17770 if (!SWIG_IsOK(ecode3)) {
17771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17772 }
17773 arg3 = static_cast< int >(val3);
17774 }
17775 if (obj3) {
17776 ecode4 = SWIG_AsVal_int(obj3, &val4);
17777 if (!SWIG_IsOK(ecode4)) {
17778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17779 }
17780 arg4 = static_cast< int >(val4);
17781 }
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 {
17789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17798 PyObject *obj;
17799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17800 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17801 return SWIG_Py_Void();
17802 }
17803
17804 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17805 PyObject *resultobj = 0;
17806 wxEvtHandler *result = 0 ;
17807
17808 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (wxEvtHandler *)new wxEvtHandler();
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17816 return resultobj;
17817 fail:
17818 return NULL;
17819 }
17820
17821
17822 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17823 PyObject *resultobj = 0;
17824 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17825 wxEvtHandler *result = 0 ;
17826 void *argp1 = 0 ;
17827 int res1 = 0 ;
17828 PyObject *swig_obj[1] ;
17829
17830 if (!args) SWIG_fail;
17831 swig_obj[0] = args;
17832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17833 if (!SWIG_IsOK(res1)) {
17834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17835 }
17836 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17837 {
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17840 wxPyEndAllowThreads(__tstate);
17841 if (PyErr_Occurred()) SWIG_fail;
17842 }
17843 {
17844 resultobj = wxPyMake_wxObject(result, 0);
17845 }
17846 return resultobj;
17847 fail:
17848 return NULL;
17849 }
17850
17851
17852 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17853 PyObject *resultobj = 0;
17854 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17855 wxEvtHandler *result = 0 ;
17856 void *argp1 = 0 ;
17857 int res1 = 0 ;
17858 PyObject *swig_obj[1] ;
17859
17860 if (!args) SWIG_fail;
17861 swig_obj[0] = args;
17862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17863 if (!SWIG_IsOK(res1)) {
17864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17865 }
17866 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17870 wxPyEndAllowThreads(__tstate);
17871 if (PyErr_Occurred()) SWIG_fail;
17872 }
17873 {
17874 resultobj = wxPyMake_wxObject(result, 0);
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17883 PyObject *resultobj = 0;
17884 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17885 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 void *argp2 = 0 ;
17889 int res2 = 0 ;
17890 PyObject * obj0 = 0 ;
17891 PyObject * obj1 = 0 ;
17892 char * kwnames[] = {
17893 (char *) "self",(char *) "handler", NULL
17894 };
17895
17896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17898 if (!SWIG_IsOK(res1)) {
17899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17900 }
17901 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17902 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17903 if (!SWIG_IsOK(res2)) {
17904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17905 }
17906 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 (arg1)->SetNextHandler(arg2);
17910 wxPyEndAllowThreads(__tstate);
17911 if (PyErr_Occurred()) SWIG_fail;
17912 }
17913 resultobj = SWIG_Py_Void();
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj = 0;
17922 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17923 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17924 void *argp1 = 0 ;
17925 int res1 = 0 ;
17926 void *argp2 = 0 ;
17927 int res2 = 0 ;
17928 PyObject * obj0 = 0 ;
17929 PyObject * obj1 = 0 ;
17930 char * kwnames[] = {
17931 (char *) "self",(char *) "handler", NULL
17932 };
17933
17934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17936 if (!SWIG_IsOK(res1)) {
17937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17938 }
17939 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17941 if (!SWIG_IsOK(res2)) {
17942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17943 }
17944 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 (arg1)->SetPreviousHandler(arg2);
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 resultobj = SWIG_Py_Void();
17952 return resultobj;
17953 fail:
17954 return NULL;
17955 }
17956
17957
17958 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17959 PyObject *resultobj = 0;
17960 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17961 bool result;
17962 void *argp1 = 0 ;
17963 int res1 = 0 ;
17964 PyObject *swig_obj[1] ;
17965
17966 if (!args) SWIG_fail;
17967 swig_obj[0] = args;
17968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17969 if (!SWIG_IsOK(res1)) {
17970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17971 }
17972 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 result = (bool)(arg1)->GetEvtHandlerEnabled();
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 {
17980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17981 }
17982 return resultobj;
17983 fail:
17984 return NULL;
17985 }
17986
17987
17988 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17989 PyObject *resultobj = 0;
17990 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17991 bool arg2 ;
17992 void *argp1 = 0 ;
17993 int res1 = 0 ;
17994 bool val2 ;
17995 int ecode2 = 0 ;
17996 PyObject * obj0 = 0 ;
17997 PyObject * obj1 = 0 ;
17998 char * kwnames[] = {
17999 (char *) "self",(char *) "enabled", NULL
18000 };
18001
18002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18004 if (!SWIG_IsOK(res1)) {
18005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18006 }
18007 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18009 if (!SWIG_IsOK(ecode2)) {
18010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18011 }
18012 arg2 = static_cast< bool >(val2);
18013 {
18014 PyThreadState* __tstate = wxPyBeginAllowThreads();
18015 (arg1)->SetEvtHandlerEnabled(arg2);
18016 wxPyEndAllowThreads(__tstate);
18017 if (PyErr_Occurred()) SWIG_fail;
18018 }
18019 resultobj = SWIG_Py_Void();
18020 return resultobj;
18021 fail:
18022 return NULL;
18023 }
18024
18025
18026 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18027 PyObject *resultobj = 0;
18028 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18029 wxEvent *arg2 = 0 ;
18030 bool result;
18031 void *argp1 = 0 ;
18032 int res1 = 0 ;
18033 void *argp2 = 0 ;
18034 int res2 = 0 ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char * kwnames[] = {
18038 (char *) "self",(char *) "event", NULL
18039 };
18040
18041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18043 if (!SWIG_IsOK(res1)) {
18044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18045 }
18046 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18048 if (!SWIG_IsOK(res2)) {
18049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18050 }
18051 if (!argp2) {
18052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18053 }
18054 arg2 = reinterpret_cast< wxEvent * >(argp2);
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 result = (bool)(arg1)->ProcessEvent(*arg2);
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 {
18062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18063 }
18064 return resultobj;
18065 fail:
18066 return NULL;
18067 }
18068
18069
18070 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj = 0;
18072 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18073 wxEvent *arg2 = 0 ;
18074 void *argp1 = 0 ;
18075 int res1 = 0 ;
18076 void *argp2 = 0 ;
18077 int res2 = 0 ;
18078 PyObject * obj0 = 0 ;
18079 PyObject * obj1 = 0 ;
18080 char * kwnames[] = {
18081 (char *) "self",(char *) "event", NULL
18082 };
18083
18084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18088 }
18089 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18091 if (!SWIG_IsOK(res2)) {
18092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18093 }
18094 if (!argp2) {
18095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18096 }
18097 arg2 = reinterpret_cast< wxEvent * >(argp2);
18098 {
18099 PyThreadState* __tstate = wxPyBeginAllowThreads();
18100 (arg1)->AddPendingEvent(*arg2);
18101 wxPyEndAllowThreads(__tstate);
18102 if (PyErr_Occurred()) SWIG_fail;
18103 }
18104 resultobj = SWIG_Py_Void();
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18112 PyObject *resultobj = 0;
18113 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18114 void *argp1 = 0 ;
18115 int res1 = 0 ;
18116 PyObject *swig_obj[1] ;
18117
18118 if (!args) SWIG_fail;
18119 swig_obj[0] = args;
18120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18121 if (!SWIG_IsOK(res1)) {
18122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18123 }
18124 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18125 {
18126 PyThreadState* __tstate = wxPyBeginAllowThreads();
18127 (arg1)->ProcessPendingEvents();
18128 wxPyEndAllowThreads(__tstate);
18129 if (PyErr_Occurred()) SWIG_fail;
18130 }
18131 resultobj = SWIG_Py_Void();
18132 return resultobj;
18133 fail:
18134 return NULL;
18135 }
18136
18137
18138 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18139 PyObject *resultobj = 0;
18140 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18141 int arg2 ;
18142 int arg3 ;
18143 int arg4 ;
18144 PyObject *arg5 = (PyObject *) 0 ;
18145 void *argp1 = 0 ;
18146 int res1 = 0 ;
18147 int val2 ;
18148 int ecode2 = 0 ;
18149 int val3 ;
18150 int ecode3 = 0 ;
18151 int val4 ;
18152 int ecode4 = 0 ;
18153 PyObject * obj0 = 0 ;
18154 PyObject * obj1 = 0 ;
18155 PyObject * obj2 = 0 ;
18156 PyObject * obj3 = 0 ;
18157 PyObject * obj4 = 0 ;
18158 char * kwnames[] = {
18159 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18160 };
18161
18162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18164 if (!SWIG_IsOK(res1)) {
18165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18166 }
18167 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18168 ecode2 = SWIG_AsVal_int(obj1, &val2);
18169 if (!SWIG_IsOK(ecode2)) {
18170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18171 }
18172 arg2 = static_cast< int >(val2);
18173 ecode3 = SWIG_AsVal_int(obj2, &val3);
18174 if (!SWIG_IsOK(ecode3)) {
18175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18176 }
18177 arg3 = static_cast< int >(val3);
18178 ecode4 = SWIG_AsVal_int(obj3, &val4);
18179 if (!SWIG_IsOK(ecode4)) {
18180 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18181 }
18182 arg4 = static_cast< int >(val4);
18183 arg5 = obj4;
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_Py_Void();
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj = 0;
18199 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18200 int arg2 ;
18201 int arg3 = (int) -1 ;
18202 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18203 bool result;
18204 void *argp1 = 0 ;
18205 int res1 = 0 ;
18206 int val2 ;
18207 int ecode2 = 0 ;
18208 int val3 ;
18209 int ecode3 = 0 ;
18210 int val4 ;
18211 int ecode4 = 0 ;
18212 PyObject * obj0 = 0 ;
18213 PyObject * obj1 = 0 ;
18214 PyObject * obj2 = 0 ;
18215 PyObject * obj3 = 0 ;
18216 char * kwnames[] = {
18217 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18218 };
18219
18220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18222 if (!SWIG_IsOK(res1)) {
18223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18224 }
18225 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18226 ecode2 = SWIG_AsVal_int(obj1, &val2);
18227 if (!SWIG_IsOK(ecode2)) {
18228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18229 }
18230 arg2 = static_cast< int >(val2);
18231 if (obj2) {
18232 ecode3 = SWIG_AsVal_int(obj2, &val3);
18233 if (!SWIG_IsOK(ecode3)) {
18234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18235 }
18236 arg3 = static_cast< int >(val3);
18237 }
18238 if (obj3) {
18239 ecode4 = SWIG_AsVal_int(obj3, &val4);
18240 if (!SWIG_IsOK(ecode4)) {
18241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18242 }
18243 arg4 = static_cast< wxEventType >(val4);
18244 }
18245 {
18246 PyThreadState* __tstate = wxPyBeginAllowThreads();
18247 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18248 wxPyEndAllowThreads(__tstate);
18249 if (PyErr_Occurred()) SWIG_fail;
18250 }
18251 {
18252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18253 }
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj = 0;
18262 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18263 PyObject *arg2 = (PyObject *) 0 ;
18264 bool arg3 = (bool) true ;
18265 void *argp1 = 0 ;
18266 int res1 = 0 ;
18267 bool val3 ;
18268 int ecode3 = 0 ;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 PyObject * obj2 = 0 ;
18272 char * kwnames[] = {
18273 (char *) "self",(char *) "_self",(char *) "incref", NULL
18274 };
18275
18276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18280 }
18281 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18282 arg2 = obj1;
18283 if (obj2) {
18284 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18285 if (!SWIG_IsOK(ecode3)) {
18286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18287 }
18288 arg3 = static_cast< bool >(val3);
18289 }
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 resultobj = SWIG_Py_Void();
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18304 PyObject *obj;
18305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18306 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18307 return SWIG_Py_Void();
18308 }
18309
18310 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18311 return SWIG_Python_InitShadowInstance(args);
18312 }
18313
18314 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18315 PyObject *resultobj = 0;
18316 wxEventType result;
18317
18318 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18319 {
18320 PyThreadState* __tstate = wxPyBeginAllowThreads();
18321 result = (wxEventType)wxNewEventType();
18322 wxPyEndAllowThreads(__tstate);
18323 if (PyErr_Occurred()) SWIG_fail;
18324 }
18325 resultobj = SWIG_From_int(static_cast< int >(result));
18326 return resultobj;
18327 fail:
18328 return NULL;
18329 }
18330
18331
18332 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18333 PyObject *resultobj = 0;
18334 wxEvent *arg1 = (wxEvent *) 0 ;
18335 void *argp1 = 0 ;
18336 int res1 = 0 ;
18337 PyObject *swig_obj[1] ;
18338
18339 if (!args) SWIG_fail;
18340 swig_obj[0] = args;
18341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18344 }
18345 arg1 = reinterpret_cast< wxEvent * >(argp1);
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 delete arg1;
18349
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_Py_Void();
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18361 PyObject *resultobj = 0;
18362 wxEvent *arg1 = (wxEvent *) 0 ;
18363 wxEventType arg2 ;
18364 void *argp1 = 0 ;
18365 int res1 = 0 ;
18366 int val2 ;
18367 int ecode2 = 0 ;
18368 PyObject * obj0 = 0 ;
18369 PyObject * obj1 = 0 ;
18370 char * kwnames[] = {
18371 (char *) "self",(char *) "typ", NULL
18372 };
18373
18374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18376 if (!SWIG_IsOK(res1)) {
18377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18378 }
18379 arg1 = reinterpret_cast< wxEvent * >(argp1);
18380 ecode2 = SWIG_AsVal_int(obj1, &val2);
18381 if (!SWIG_IsOK(ecode2)) {
18382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18383 }
18384 arg2 = static_cast< wxEventType >(val2);
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 (arg1)->SetEventType(arg2);
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = SWIG_Py_Void();
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18399 PyObject *resultobj = 0;
18400 wxEvent *arg1 = (wxEvent *) 0 ;
18401 wxEventType result;
18402 void *argp1 = 0 ;
18403 int res1 = 0 ;
18404 PyObject *swig_obj[1] ;
18405
18406 if (!args) SWIG_fail;
18407 swig_obj[0] = args;
18408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18409 if (!SWIG_IsOK(res1)) {
18410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18411 }
18412 arg1 = reinterpret_cast< wxEvent * >(argp1);
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_From_int(static_cast< int >(result));
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18427 PyObject *resultobj = 0;
18428 wxEvent *arg1 = (wxEvent *) 0 ;
18429 wxObject *result = 0 ;
18430 void *argp1 = 0 ;
18431 int res1 = 0 ;
18432 PyObject *swig_obj[1] ;
18433
18434 if (!args) SWIG_fail;
18435 swig_obj[0] = args;
18436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18437 if (!SWIG_IsOK(res1)) {
18438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18439 }
18440 arg1 = reinterpret_cast< wxEvent * >(argp1);
18441 {
18442 PyThreadState* __tstate = wxPyBeginAllowThreads();
18443 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18444 wxPyEndAllowThreads(__tstate);
18445 if (PyErr_Occurred()) SWIG_fail;
18446 }
18447 {
18448 resultobj = wxPyMake_wxObject(result, (bool)0);
18449 }
18450 return resultobj;
18451 fail:
18452 return NULL;
18453 }
18454
18455
18456 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18457 PyObject *resultobj = 0;
18458 wxEvent *arg1 = (wxEvent *) 0 ;
18459 wxObject *arg2 = (wxObject *) 0 ;
18460 void *argp1 = 0 ;
18461 int res1 = 0 ;
18462 void *argp2 = 0 ;
18463 int res2 = 0 ;
18464 PyObject * obj0 = 0 ;
18465 PyObject * obj1 = 0 ;
18466 char * kwnames[] = {
18467 (char *) "self",(char *) "obj", NULL
18468 };
18469
18470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18474 }
18475 arg1 = reinterpret_cast< wxEvent * >(argp1);
18476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18477 if (!SWIG_IsOK(res2)) {
18478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18479 }
18480 arg2 = reinterpret_cast< wxObject * >(argp2);
18481 {
18482 PyThreadState* __tstate = wxPyBeginAllowThreads();
18483 (arg1)->SetEventObject(arg2);
18484 wxPyEndAllowThreads(__tstate);
18485 if (PyErr_Occurred()) SWIG_fail;
18486 }
18487 resultobj = SWIG_Py_Void();
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18495 PyObject *resultobj = 0;
18496 wxEvent *arg1 = (wxEvent *) 0 ;
18497 long result;
18498 void *argp1 = 0 ;
18499 int res1 = 0 ;
18500 PyObject *swig_obj[1] ;
18501
18502 if (!args) SWIG_fail;
18503 swig_obj[0] = args;
18504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18505 if (!SWIG_IsOK(res1)) {
18506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18507 }
18508 arg1 = reinterpret_cast< wxEvent * >(argp1);
18509 {
18510 PyThreadState* __tstate = wxPyBeginAllowThreads();
18511 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18512 wxPyEndAllowThreads(__tstate);
18513 if (PyErr_Occurred()) SWIG_fail;
18514 }
18515 resultobj = SWIG_From_long(static_cast< long >(result));
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj = 0;
18524 wxEvent *arg1 = (wxEvent *) 0 ;
18525 long arg2 = (long) 0 ;
18526 void *argp1 = 0 ;
18527 int res1 = 0 ;
18528 long val2 ;
18529 int ecode2 = 0 ;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 char * kwnames[] = {
18533 (char *) "self",(char *) "ts", NULL
18534 };
18535
18536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18540 }
18541 arg1 = reinterpret_cast< wxEvent * >(argp1);
18542 if (obj1) {
18543 ecode2 = SWIG_AsVal_long(obj1, &val2);
18544 if (!SWIG_IsOK(ecode2)) {
18545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18546 }
18547 arg2 = static_cast< long >(val2);
18548 }
18549 {
18550 PyThreadState* __tstate = wxPyBeginAllowThreads();
18551 (arg1)->SetTimestamp(arg2);
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 resultobj = SWIG_Py_Void();
18556 return resultobj;
18557 fail:
18558 return NULL;
18559 }
18560
18561
18562 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18563 PyObject *resultobj = 0;
18564 wxEvent *arg1 = (wxEvent *) 0 ;
18565 int result;
18566 void *argp1 = 0 ;
18567 int res1 = 0 ;
18568 PyObject *swig_obj[1] ;
18569
18570 if (!args) SWIG_fail;
18571 swig_obj[0] = args;
18572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18573 if (!SWIG_IsOK(res1)) {
18574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18575 }
18576 arg1 = reinterpret_cast< wxEvent * >(argp1);
18577 {
18578 PyThreadState* __tstate = wxPyBeginAllowThreads();
18579 result = (int)((wxEvent const *)arg1)->GetId();
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 resultobj = SWIG_From_int(static_cast< int >(result));
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18591 PyObject *resultobj = 0;
18592 wxEvent *arg1 = (wxEvent *) 0 ;
18593 int arg2 ;
18594 void *argp1 = 0 ;
18595 int res1 = 0 ;
18596 int val2 ;
18597 int ecode2 = 0 ;
18598 PyObject * obj0 = 0 ;
18599 PyObject * obj1 = 0 ;
18600 char * kwnames[] = {
18601 (char *) "self",(char *) "Id", NULL
18602 };
18603
18604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18608 }
18609 arg1 = reinterpret_cast< wxEvent * >(argp1);
18610 ecode2 = SWIG_AsVal_int(obj1, &val2);
18611 if (!SWIG_IsOK(ecode2)) {
18612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18613 }
18614 arg2 = static_cast< int >(val2);
18615 {
18616 PyThreadState* __tstate = wxPyBeginAllowThreads();
18617 (arg1)->SetId(arg2);
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 resultobj = SWIG_Py_Void();
18622 return resultobj;
18623 fail:
18624 return NULL;
18625 }
18626
18627
18628 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18629 PyObject *resultobj = 0;
18630 wxEvent *arg1 = (wxEvent *) 0 ;
18631 bool result;
18632 void *argp1 = 0 ;
18633 int res1 = 0 ;
18634 PyObject *swig_obj[1] ;
18635
18636 if (!args) SWIG_fail;
18637 swig_obj[0] = args;
18638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18641 }
18642 arg1 = reinterpret_cast< wxEvent * >(argp1);
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 {
18650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18651 }
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18659 PyObject *resultobj = 0;
18660 wxEvent *arg1 = (wxEvent *) 0 ;
18661 bool arg2 = (bool) true ;
18662 void *argp1 = 0 ;
18663 int res1 = 0 ;
18664 bool val2 ;
18665 int ecode2 = 0 ;
18666 PyObject * obj0 = 0 ;
18667 PyObject * obj1 = 0 ;
18668 char * kwnames[] = {
18669 (char *) "self",(char *) "skip", NULL
18670 };
18671
18672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18676 }
18677 arg1 = reinterpret_cast< wxEvent * >(argp1);
18678 if (obj1) {
18679 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18680 if (!SWIG_IsOK(ecode2)) {
18681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18682 }
18683 arg2 = static_cast< bool >(val2);
18684 }
18685 {
18686 PyThreadState* __tstate = wxPyBeginAllowThreads();
18687 (arg1)->Skip(arg2);
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 resultobj = SWIG_Py_Void();
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18699 PyObject *resultobj = 0;
18700 wxEvent *arg1 = (wxEvent *) 0 ;
18701 bool result;
18702 void *argp1 = 0 ;
18703 int res1 = 0 ;
18704 PyObject *swig_obj[1] ;
18705
18706 if (!args) SWIG_fail;
18707 swig_obj[0] = args;
18708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18709 if (!SWIG_IsOK(res1)) {
18710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18711 }
18712 arg1 = reinterpret_cast< wxEvent * >(argp1);
18713 {
18714 PyThreadState* __tstate = wxPyBeginAllowThreads();
18715 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18716 wxPyEndAllowThreads(__tstate);
18717 if (PyErr_Occurred()) SWIG_fail;
18718 }
18719 {
18720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18721 }
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18729 PyObject *resultobj = 0;
18730 wxEvent *arg1 = (wxEvent *) 0 ;
18731 bool result;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject *swig_obj[1] ;
18735
18736 if (!args) SWIG_fail;
18737 swig_obj[0] = args;
18738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18741 }
18742 arg1 = reinterpret_cast< wxEvent * >(argp1);
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 {
18750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18751 }
18752 return resultobj;
18753 fail:
18754 return NULL;
18755 }
18756
18757
18758 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 PyObject *resultobj = 0;
18760 wxEvent *arg1 = (wxEvent *) 0 ;
18761 int result;
18762 void *argp1 = 0 ;
18763 int res1 = 0 ;
18764 PyObject *swig_obj[1] ;
18765
18766 if (!args) SWIG_fail;
18767 swig_obj[0] = args;
18768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18769 if (!SWIG_IsOK(res1)) {
18770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18771 }
18772 arg1 = reinterpret_cast< wxEvent * >(argp1);
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (int)(arg1)->StopPropagation();
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 resultobj = SWIG_From_int(static_cast< int >(result));
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18787 PyObject *resultobj = 0;
18788 wxEvent *arg1 = (wxEvent *) 0 ;
18789 int arg2 ;
18790 void *argp1 = 0 ;
18791 int res1 = 0 ;
18792 int val2 ;
18793 int ecode2 = 0 ;
18794 PyObject * obj0 = 0 ;
18795 PyObject * obj1 = 0 ;
18796 char * kwnames[] = {
18797 (char *) "self",(char *) "propagationLevel", NULL
18798 };
18799
18800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18802 if (!SWIG_IsOK(res1)) {
18803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18804 }
18805 arg1 = reinterpret_cast< wxEvent * >(argp1);
18806 ecode2 = SWIG_AsVal_int(obj1, &val2);
18807 if (!SWIG_IsOK(ecode2)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18809 }
18810 arg2 = static_cast< int >(val2);
18811 {
18812 PyThreadState* __tstate = wxPyBeginAllowThreads();
18813 (arg1)->ResumePropagation(arg2);
18814 wxPyEndAllowThreads(__tstate);
18815 if (PyErr_Occurred()) SWIG_fail;
18816 }
18817 resultobj = SWIG_Py_Void();
18818 return resultobj;
18819 fail:
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 wxEvent *arg1 = (wxEvent *) 0 ;
18827 wxEvent *result = 0 ;
18828 void *argp1 = 0 ;
18829 int res1 = 0 ;
18830 PyObject *swig_obj[1] ;
18831
18832 if (!args) SWIG_fail;
18833 swig_obj[0] = args;
18834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18835 if (!SWIG_IsOK(res1)) {
18836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18837 }
18838 arg1 = reinterpret_cast< wxEvent * >(argp1);
18839 {
18840 PyThreadState* __tstate = wxPyBeginAllowThreads();
18841 result = (wxEvent *)(arg1)->Clone();
18842 wxPyEndAllowThreads(__tstate);
18843 if (PyErr_Occurred()) SWIG_fail;
18844 }
18845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18846 return resultobj;
18847 fail:
18848 return NULL;
18849 }
18850
18851
18852 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18853 PyObject *obj;
18854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18855 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18856 return SWIG_Py_Void();
18857 }
18858
18859 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18860 PyObject *resultobj = 0;
18861 wxEvent *arg1 = 0 ;
18862 wxPropagationDisabler *result = 0 ;
18863 void *argp1 = 0 ;
18864 int res1 = 0 ;
18865 PyObject * obj0 = 0 ;
18866 char * kwnames[] = {
18867 (char *) "event", NULL
18868 };
18869
18870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18871 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18872 if (!SWIG_IsOK(res1)) {
18873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18874 }
18875 if (!argp1) {
18876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18877 }
18878 arg1 = reinterpret_cast< wxEvent * >(argp1);
18879 {
18880 PyThreadState* __tstate = wxPyBeginAllowThreads();
18881 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18882 wxPyEndAllowThreads(__tstate);
18883 if (PyErr_Occurred()) SWIG_fail;
18884 }
18885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18886 return resultobj;
18887 fail:
18888 return NULL;
18889 }
18890
18891
18892 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18893 PyObject *resultobj = 0;
18894 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18895 void *argp1 = 0 ;
18896 int res1 = 0 ;
18897 PyObject *swig_obj[1] ;
18898
18899 if (!args) SWIG_fail;
18900 swig_obj[0] = args;
18901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18902 if (!SWIG_IsOK(res1)) {
18903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18904 }
18905 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 delete arg1;
18909
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 resultobj = SWIG_Py_Void();
18914 return resultobj;
18915 fail:
18916 return NULL;
18917 }
18918
18919
18920 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18921 PyObject *obj;
18922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18923 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18924 return SWIG_Py_Void();
18925 }
18926
18927 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18928 return SWIG_Python_InitShadowInstance(args);
18929 }
18930
18931 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18932 PyObject *resultobj = 0;
18933 wxEvent *arg1 = 0 ;
18934 wxPropagateOnce *result = 0 ;
18935 void *argp1 = 0 ;
18936 int res1 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 char * kwnames[] = {
18939 (char *) "event", NULL
18940 };
18941
18942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18943 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18946 }
18947 if (!argp1) {
18948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18949 }
18950 arg1 = reinterpret_cast< wxEvent * >(argp1);
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18965 PyObject *resultobj = 0;
18966 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18967 void *argp1 = 0 ;
18968 int res1 = 0 ;
18969 PyObject *swig_obj[1] ;
18970
18971 if (!args) SWIG_fail;
18972 swig_obj[0] = args;
18973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18974 if (!SWIG_IsOK(res1)) {
18975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18976 }
18977 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18978 {
18979 PyThreadState* __tstate = wxPyBeginAllowThreads();
18980 delete arg1;
18981
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 resultobj = SWIG_Py_Void();
18986 return resultobj;
18987 fail:
18988 return NULL;
18989 }
18990
18991
18992 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18993 PyObject *obj;
18994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18995 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18996 return SWIG_Py_Void();
18997 }
18998
18999 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19000 return SWIG_Python_InitShadowInstance(args);
19001 }
19002
19003 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj = 0;
19005 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19006 int arg2 = (int) 0 ;
19007 wxCommandEvent *result = 0 ;
19008 int val1 ;
19009 int ecode1 = 0 ;
19010 int val2 ;
19011 int ecode2 = 0 ;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 char * kwnames[] = {
19015 (char *) "commandType",(char *) "winid", NULL
19016 };
19017
19018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19019 if (obj0) {
19020 ecode1 = SWIG_AsVal_int(obj0, &val1);
19021 if (!SWIG_IsOK(ecode1)) {
19022 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19023 }
19024 arg1 = static_cast< wxEventType >(val1);
19025 }
19026 if (obj1) {
19027 ecode2 = SWIG_AsVal_int(obj1, &val2);
19028 if (!SWIG_IsOK(ecode2)) {
19029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19030 }
19031 arg2 = static_cast< int >(val2);
19032 }
19033 {
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19047 PyObject *resultobj = 0;
19048 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19049 int result;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 PyObject *swig_obj[1] ;
19053
19054 if (!args) SWIG_fail;
19055 swig_obj[0] = args;
19056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19057 if (!SWIG_IsOK(res1)) {
19058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19059 }
19060 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = SWIG_From_int(static_cast< int >(result));
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19075 PyObject *resultobj = 0;
19076 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19077 wxString *arg2 = 0 ;
19078 void *argp1 = 0 ;
19079 int res1 = 0 ;
19080 bool temp2 = false ;
19081 PyObject * obj0 = 0 ;
19082 PyObject * obj1 = 0 ;
19083 char * kwnames[] = {
19084 (char *) "self",(char *) "s", NULL
19085 };
19086
19087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19089 if (!SWIG_IsOK(res1)) {
19090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19091 }
19092 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19093 {
19094 arg2 = wxString_in_helper(obj1);
19095 if (arg2 == NULL) SWIG_fail;
19096 temp2 = true;
19097 }
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 (arg1)->SetString((wxString const &)*arg2);
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 resultobj = SWIG_Py_Void();
19105 {
19106 if (temp2)
19107 delete arg2;
19108 }
19109 return resultobj;
19110 fail:
19111 {
19112 if (temp2)
19113 delete arg2;
19114 }
19115 return NULL;
19116 }
19117
19118
19119 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19120 PyObject *resultobj = 0;
19121 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19122 wxString result;
19123 void *argp1 = 0 ;
19124 int res1 = 0 ;
19125 PyObject *swig_obj[1] ;
19126
19127 if (!args) SWIG_fail;
19128 swig_obj[0] = args;
19129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19130 if (!SWIG_IsOK(res1)) {
19131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19132 }
19133 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = ((wxCommandEvent const *)arg1)->GetString();
19137 wxPyEndAllowThreads(__tstate);
19138 if (PyErr_Occurred()) SWIG_fail;
19139 }
19140 {
19141 #if wxUSE_UNICODE
19142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19143 #else
19144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19145 #endif
19146 }
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19154 PyObject *resultobj = 0;
19155 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19156 bool result;
19157 void *argp1 = 0 ;
19158 int res1 = 0 ;
19159 PyObject *swig_obj[1] ;
19160
19161 if (!args) SWIG_fail;
19162 swig_obj[0] = args;
19163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19166 }
19167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 {
19175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19176 }
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19184 PyObject *resultobj = 0;
19185 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19186 bool result;
19187 void *argp1 = 0 ;
19188 int res1 = 0 ;
19189 PyObject *swig_obj[1] ;
19190
19191 if (!args) SWIG_fail;
19192 swig_obj[0] = args;
19193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19194 if (!SWIG_IsOK(res1)) {
19195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19196 }
19197 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19201 wxPyEndAllowThreads(__tstate);
19202 if (PyErr_Occurred()) SWIG_fail;
19203 }
19204 {
19205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19206 }
19207 return resultobj;
19208 fail:
19209 return NULL;
19210 }
19211
19212
19213 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj = 0;
19215 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19216 long arg2 ;
19217 void *argp1 = 0 ;
19218 int res1 = 0 ;
19219 long val2 ;
19220 int ecode2 = 0 ;
19221 PyObject * obj0 = 0 ;
19222 PyObject * obj1 = 0 ;
19223 char * kwnames[] = {
19224 (char *) "self",(char *) "extraLong", NULL
19225 };
19226
19227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19231 }
19232 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19233 ecode2 = SWIG_AsVal_long(obj1, &val2);
19234 if (!SWIG_IsOK(ecode2)) {
19235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19236 }
19237 arg2 = static_cast< long >(val2);
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 (arg1)->SetExtraLong(arg2);
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 resultobj = SWIG_Py_Void();
19245 return resultobj;
19246 fail:
19247 return NULL;
19248 }
19249
19250
19251 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19252 PyObject *resultobj = 0;
19253 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19254 long result;
19255 void *argp1 = 0 ;
19256 int res1 = 0 ;
19257 PyObject *swig_obj[1] ;
19258
19259 if (!args) SWIG_fail;
19260 swig_obj[0] = args;
19261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19262 if (!SWIG_IsOK(res1)) {
19263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19264 }
19265 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19266 {
19267 PyThreadState* __tstate = wxPyBeginAllowThreads();
19268 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19269 wxPyEndAllowThreads(__tstate);
19270 if (PyErr_Occurred()) SWIG_fail;
19271 }
19272 resultobj = SWIG_From_long(static_cast< long >(result));
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj = 0;
19281 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19282 int arg2 ;
19283 void *argp1 = 0 ;
19284 int res1 = 0 ;
19285 int val2 ;
19286 int ecode2 = 0 ;
19287 PyObject * obj0 = 0 ;
19288 PyObject * obj1 = 0 ;
19289 char * kwnames[] = {
19290 (char *) "self",(char *) "i", NULL
19291 };
19292
19293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19295 if (!SWIG_IsOK(res1)) {
19296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19297 }
19298 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19299 ecode2 = SWIG_AsVal_int(obj1, &val2);
19300 if (!SWIG_IsOK(ecode2)) {
19301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19302 }
19303 arg2 = static_cast< int >(val2);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 (arg1)->SetInt(arg2);
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_Py_Void();
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *resultobj = 0;
19319 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19320 int result;
19321 void *argp1 = 0 ;
19322 int res1 = 0 ;
19323 PyObject *swig_obj[1] ;
19324
19325 if (!args) SWIG_fail;
19326 swig_obj[0] = args;
19327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19328 if (!SWIG_IsOK(res1)) {
19329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19330 }
19331 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 resultobj = SWIG_From_int(static_cast< int >(result));
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19346 PyObject *resultobj = 0;
19347 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19348 PyObject *result = 0 ;
19349 void *argp1 = 0 ;
19350 int res1 = 0 ;
19351 PyObject *swig_obj[1] ;
19352
19353 if (!args) SWIG_fail;
19354 swig_obj[0] = args;
19355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19356 if (!SWIG_IsOK(res1)) {
19357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19358 }
19359 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19363 wxPyEndAllowThreads(__tstate);
19364 if (PyErr_Occurred()) SWIG_fail;
19365 }
19366 resultobj = result;
19367 return resultobj;
19368 fail:
19369 return NULL;
19370 }
19371
19372
19373 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19374 PyObject *resultobj = 0;
19375 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19376 PyObject *arg2 = (PyObject *) 0 ;
19377 void *argp1 = 0 ;
19378 int res1 = 0 ;
19379 PyObject * obj0 = 0 ;
19380 PyObject * obj1 = 0 ;
19381 char * kwnames[] = {
19382 (char *) "self",(char *) "clientData", NULL
19383 };
19384
19385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19387 if (!SWIG_IsOK(res1)) {
19388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19389 }
19390 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19391 arg2 = obj1;
19392 {
19393 PyThreadState* __tstate = wxPyBeginAllowThreads();
19394 wxCommandEvent_SetClientData(arg1,arg2);
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 resultobj = SWIG_Py_Void();
19399 return resultobj;
19400 fail:
19401 return NULL;
19402 }
19403
19404
19405 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19406 PyObject *resultobj = 0;
19407 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19408 wxEvent *result = 0 ;
19409 void *argp1 = 0 ;
19410 int res1 = 0 ;
19411 PyObject *swig_obj[1] ;
19412
19413 if (!args) SWIG_fail;
19414 swig_obj[0] = args;
19415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19416 if (!SWIG_IsOK(res1)) {
19417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19418 }
19419 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19420 {
19421 PyThreadState* __tstate = wxPyBeginAllowThreads();
19422 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19423 wxPyEndAllowThreads(__tstate);
19424 if (PyErr_Occurred()) SWIG_fail;
19425 }
19426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19427 return resultobj;
19428 fail:
19429 return NULL;
19430 }
19431
19432
19433 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19434 PyObject *obj;
19435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19436 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19437 return SWIG_Py_Void();
19438 }
19439
19440 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19441 return SWIG_Python_InitShadowInstance(args);
19442 }
19443
19444 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj = 0;
19446 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19447 int arg2 = (int) 0 ;
19448 wxNotifyEvent *result = 0 ;
19449 int val1 ;
19450 int ecode1 = 0 ;
19451 int val2 ;
19452 int ecode2 = 0 ;
19453 PyObject * obj0 = 0 ;
19454 PyObject * obj1 = 0 ;
19455 char * kwnames[] = {
19456 (char *) "commandType",(char *) "winid", NULL
19457 };
19458
19459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19460 if (obj0) {
19461 ecode1 = SWIG_AsVal_int(obj0, &val1);
19462 if (!SWIG_IsOK(ecode1)) {
19463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19464 }
19465 arg1 = static_cast< wxEventType >(val1);
19466 }
19467 if (obj1) {
19468 ecode2 = SWIG_AsVal_int(obj1, &val2);
19469 if (!SWIG_IsOK(ecode2)) {
19470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19471 }
19472 arg2 = static_cast< int >(val2);
19473 }
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *resultobj = 0;
19489 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19490 void *argp1 = 0 ;
19491 int res1 = 0 ;
19492 PyObject *swig_obj[1] ;
19493
19494 if (!args) SWIG_fail;
19495 swig_obj[0] = args;
19496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19497 if (!SWIG_IsOK(res1)) {
19498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19499 }
19500 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 (arg1)->Veto();
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_Py_Void();
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 PyObject *resultobj = 0;
19516 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19517 void *argp1 = 0 ;
19518 int res1 = 0 ;
19519 PyObject *swig_obj[1] ;
19520
19521 if (!args) SWIG_fail;
19522 swig_obj[0] = args;
19523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19524 if (!SWIG_IsOK(res1)) {
19525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19526 }
19527 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19528 {
19529 PyThreadState* __tstate = wxPyBeginAllowThreads();
19530 (arg1)->Allow();
19531 wxPyEndAllowThreads(__tstate);
19532 if (PyErr_Occurred()) SWIG_fail;
19533 }
19534 resultobj = SWIG_Py_Void();
19535 return resultobj;
19536 fail:
19537 return NULL;
19538 }
19539
19540
19541 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19542 PyObject *resultobj = 0;
19543 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19544 bool result;
19545 void *argp1 = 0 ;
19546 int res1 = 0 ;
19547 PyObject *swig_obj[1] ;
19548
19549 if (!args) SWIG_fail;
19550 swig_obj[0] = args;
19551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19552 if (!SWIG_IsOK(res1)) {
19553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19554 }
19555 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = (bool)(arg1)->IsAllowed();
19559 wxPyEndAllowThreads(__tstate);
19560 if (PyErr_Occurred()) SWIG_fail;
19561 }
19562 {
19563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19564 }
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19572 PyObject *obj;
19573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19574 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19575 return SWIG_Py_Void();
19576 }
19577
19578 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19579 return SWIG_Python_InitShadowInstance(args);
19580 }
19581
19582 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19583 PyObject *resultobj = 0;
19584 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19585 int arg2 = (int) 0 ;
19586 int arg3 = (int) 0 ;
19587 int arg4 = (int) 0 ;
19588 wxScrollEvent *result = 0 ;
19589 int val1 ;
19590 int ecode1 = 0 ;
19591 int val2 ;
19592 int ecode2 = 0 ;
19593 int val3 ;
19594 int ecode3 = 0 ;
19595 int val4 ;
19596 int ecode4 = 0 ;
19597 PyObject * obj0 = 0 ;
19598 PyObject * obj1 = 0 ;
19599 PyObject * obj2 = 0 ;
19600 PyObject * obj3 = 0 ;
19601 char * kwnames[] = {
19602 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19603 };
19604
19605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19606 if (obj0) {
19607 ecode1 = SWIG_AsVal_int(obj0, &val1);
19608 if (!SWIG_IsOK(ecode1)) {
19609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19610 }
19611 arg1 = static_cast< wxEventType >(val1);
19612 }
19613 if (obj1) {
19614 ecode2 = SWIG_AsVal_int(obj1, &val2);
19615 if (!SWIG_IsOK(ecode2)) {
19616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19617 }
19618 arg2 = static_cast< int >(val2);
19619 }
19620 if (obj2) {
19621 ecode3 = SWIG_AsVal_int(obj2, &val3);
19622 if (!SWIG_IsOK(ecode3)) {
19623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19624 }
19625 arg3 = static_cast< int >(val3);
19626 }
19627 if (obj3) {
19628 ecode4 = SWIG_AsVal_int(obj3, &val4);
19629 if (!SWIG_IsOK(ecode4)) {
19630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19631 }
19632 arg4 = static_cast< int >(val4);
19633 }
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19641 return resultobj;
19642 fail:
19643 return NULL;
19644 }
19645
19646
19647 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19648 PyObject *resultobj = 0;
19649 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19650 int result;
19651 void *argp1 = 0 ;
19652 int res1 = 0 ;
19653 PyObject *swig_obj[1] ;
19654
19655 if (!args) SWIG_fail;
19656 swig_obj[0] = args;
19657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19658 if (!SWIG_IsOK(res1)) {
19659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19660 }
19661 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19662 {
19663 PyThreadState* __tstate = wxPyBeginAllowThreads();
19664 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19665 wxPyEndAllowThreads(__tstate);
19666 if (PyErr_Occurred()) SWIG_fail;
19667 }
19668 resultobj = SWIG_From_int(static_cast< int >(result));
19669 return resultobj;
19670 fail:
19671 return NULL;
19672 }
19673
19674
19675 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19676 PyObject *resultobj = 0;
19677 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19678 int result;
19679 void *argp1 = 0 ;
19680 int res1 = 0 ;
19681 PyObject *swig_obj[1] ;
19682
19683 if (!args) SWIG_fail;
19684 swig_obj[0] = args;
19685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19686 if (!SWIG_IsOK(res1)) {
19687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19688 }
19689 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19690 {
19691 PyThreadState* __tstate = wxPyBeginAllowThreads();
19692 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19693 wxPyEndAllowThreads(__tstate);
19694 if (PyErr_Occurred()) SWIG_fail;
19695 }
19696 resultobj = SWIG_From_int(static_cast< int >(result));
19697 return resultobj;
19698 fail:
19699 return NULL;
19700 }
19701
19702
19703 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19704 PyObject *resultobj = 0;
19705 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19706 int arg2 ;
19707 void *argp1 = 0 ;
19708 int res1 = 0 ;
19709 int val2 ;
19710 int ecode2 = 0 ;
19711 PyObject * obj0 = 0 ;
19712 PyObject * obj1 = 0 ;
19713 char * kwnames[] = {
19714 (char *) "self",(char *) "orient", NULL
19715 };
19716
19717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19721 }
19722 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19723 ecode2 = SWIG_AsVal_int(obj1, &val2);
19724 if (!SWIG_IsOK(ecode2)) {
19725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19726 }
19727 arg2 = static_cast< int >(val2);
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 (arg1)->SetOrientation(arg2);
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_Py_Void();
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj = 0;
19743 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19744 int arg2 ;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 int val2 ;
19748 int ecode2 = 0 ;
19749 PyObject * obj0 = 0 ;
19750 PyObject * obj1 = 0 ;
19751 char * kwnames[] = {
19752 (char *) "self",(char *) "pos", NULL
19753 };
19754
19755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19757 if (!SWIG_IsOK(res1)) {
19758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19759 }
19760 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19761 ecode2 = SWIG_AsVal_int(obj1, &val2);
19762 if (!SWIG_IsOK(ecode2)) {
19763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19764 }
19765 arg2 = static_cast< int >(val2);
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 (arg1)->SetPosition(arg2);
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 resultobj = SWIG_Py_Void();
19773 return resultobj;
19774 fail:
19775 return NULL;
19776 }
19777
19778
19779 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19780 PyObject *obj;
19781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19782 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19783 return SWIG_Py_Void();
19784 }
19785
19786 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19787 return SWIG_Python_InitShadowInstance(args);
19788 }
19789
19790 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19791 PyObject *resultobj = 0;
19792 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19793 int arg2 = (int) 0 ;
19794 int arg3 = (int) 0 ;
19795 wxScrollWinEvent *result = 0 ;
19796 int val1 ;
19797 int ecode1 = 0 ;
19798 int val2 ;
19799 int ecode2 = 0 ;
19800 int val3 ;
19801 int ecode3 = 0 ;
19802 PyObject * obj0 = 0 ;
19803 PyObject * obj1 = 0 ;
19804 PyObject * obj2 = 0 ;
19805 char * kwnames[] = {
19806 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19807 };
19808
19809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19810 if (obj0) {
19811 ecode1 = SWIG_AsVal_int(obj0, &val1);
19812 if (!SWIG_IsOK(ecode1)) {
19813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19814 }
19815 arg1 = static_cast< wxEventType >(val1);
19816 }
19817 if (obj1) {
19818 ecode2 = SWIG_AsVal_int(obj1, &val2);
19819 if (!SWIG_IsOK(ecode2)) {
19820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19821 }
19822 arg2 = static_cast< int >(val2);
19823 }
19824 if (obj2) {
19825 ecode3 = SWIG_AsVal_int(obj2, &val3);
19826 if (!SWIG_IsOK(ecode3)) {
19827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19828 }
19829 arg3 = static_cast< int >(val3);
19830 }
19831 {
19832 PyThreadState* __tstate = wxPyBeginAllowThreads();
19833 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19845 PyObject *resultobj = 0;
19846 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19847 int result;
19848 void *argp1 = 0 ;
19849 int res1 = 0 ;
19850 PyObject *swig_obj[1] ;
19851
19852 if (!args) SWIG_fail;
19853 swig_obj[0] = args;
19854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19855 if (!SWIG_IsOK(res1)) {
19856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19857 }
19858 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19859 {
19860 PyThreadState* __tstate = wxPyBeginAllowThreads();
19861 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19862 wxPyEndAllowThreads(__tstate);
19863 if (PyErr_Occurred()) SWIG_fail;
19864 }
19865 resultobj = SWIG_From_int(static_cast< int >(result));
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19873 PyObject *resultobj = 0;
19874 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19875 int result;
19876 void *argp1 = 0 ;
19877 int res1 = 0 ;
19878 PyObject *swig_obj[1] ;
19879
19880 if (!args) SWIG_fail;
19881 swig_obj[0] = args;
19882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19883 if (!SWIG_IsOK(res1)) {
19884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19885 }
19886 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19887 {
19888 PyThreadState* __tstate = wxPyBeginAllowThreads();
19889 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 resultobj = SWIG_From_int(static_cast< int >(result));
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj = 0;
19902 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19903 int arg2 ;
19904 void *argp1 = 0 ;
19905 int res1 = 0 ;
19906 int val2 ;
19907 int ecode2 = 0 ;
19908 PyObject * obj0 = 0 ;
19909 PyObject * obj1 = 0 ;
19910 char * kwnames[] = {
19911 (char *) "self",(char *) "orient", NULL
19912 };
19913
19914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19918 }
19919 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19920 ecode2 = SWIG_AsVal_int(obj1, &val2);
19921 if (!SWIG_IsOK(ecode2)) {
19922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19923 }
19924 arg2 = static_cast< int >(val2);
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 (arg1)->SetOrientation(arg2);
19928 wxPyEndAllowThreads(__tstate);
19929 if (PyErr_Occurred()) SWIG_fail;
19930 }
19931 resultobj = SWIG_Py_Void();
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj = 0;
19940 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19941 int arg2 ;
19942 void *argp1 = 0 ;
19943 int res1 = 0 ;
19944 int val2 ;
19945 int ecode2 = 0 ;
19946 PyObject * obj0 = 0 ;
19947 PyObject * obj1 = 0 ;
19948 char * kwnames[] = {
19949 (char *) "self",(char *) "pos", NULL
19950 };
19951
19952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19954 if (!SWIG_IsOK(res1)) {
19955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19956 }
19957 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19958 ecode2 = SWIG_AsVal_int(obj1, &val2);
19959 if (!SWIG_IsOK(ecode2)) {
19960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19961 }
19962 arg2 = static_cast< int >(val2);
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 (arg1)->SetPosition(arg2);
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 resultobj = SWIG_Py_Void();
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19977 PyObject *obj;
19978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19979 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19980 return SWIG_Py_Void();
19981 }
19982
19983 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19984 return SWIG_Python_InitShadowInstance(args);
19985 }
19986
19987 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19988 PyObject *resultobj = 0;
19989 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19990 wxMouseEvent *result = 0 ;
19991 int val1 ;
19992 int ecode1 = 0 ;
19993 PyObject * obj0 = 0 ;
19994 char * kwnames[] = {
19995 (char *) "mouseType", NULL
19996 };
19997
19998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19999 if (obj0) {
20000 ecode1 = SWIG_AsVal_int(obj0, &val1);
20001 if (!SWIG_IsOK(ecode1)) {
20002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20003 }
20004 arg1 = static_cast< wxEventType >(val1);
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 {
20013 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20014 }
20015 return resultobj;
20016 fail:
20017 return NULL;
20018 }
20019
20020
20021 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20022 PyObject *resultobj = 0;
20023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20024 bool result;
20025 void *argp1 = 0 ;
20026 int res1 = 0 ;
20027 PyObject *swig_obj[1] ;
20028
20029 if (!args) SWIG_fail;
20030 swig_obj[0] = args;
20031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20032 if (!SWIG_IsOK(res1)) {
20033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20034 }
20035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20036 {
20037 PyThreadState* __tstate = wxPyBeginAllowThreads();
20038 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20039 wxPyEndAllowThreads(__tstate);
20040 if (PyErr_Occurred()) SWIG_fail;
20041 }
20042 {
20043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20044 }
20045 return resultobj;
20046 fail:
20047 return NULL;
20048 }
20049
20050
20051 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20052 PyObject *resultobj = 0;
20053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20054 int arg2 = (int) wxMOUSE_BTN_ANY ;
20055 bool result;
20056 void *argp1 = 0 ;
20057 int res1 = 0 ;
20058 int val2 ;
20059 int ecode2 = 0 ;
20060 PyObject * obj0 = 0 ;
20061 PyObject * obj1 = 0 ;
20062 char * kwnames[] = {
20063 (char *) "self",(char *) "but", NULL
20064 };
20065
20066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20068 if (!SWIG_IsOK(res1)) {
20069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20070 }
20071 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20072 if (obj1) {
20073 ecode2 = SWIG_AsVal_int(obj1, &val2);
20074 if (!SWIG_IsOK(ecode2)) {
20075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20076 }
20077 arg2 = static_cast< int >(val2);
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 {
20086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20087 }
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj = 0;
20096 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20097 int arg2 = (int) wxMOUSE_BTN_ANY ;
20098 bool result;
20099 void *argp1 = 0 ;
20100 int res1 = 0 ;
20101 int val2 ;
20102 int ecode2 = 0 ;
20103 PyObject * obj0 = 0 ;
20104 PyObject * obj1 = 0 ;
20105 char * kwnames[] = {
20106 (char *) "self",(char *) "but", NULL
20107 };
20108
20109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20111 if (!SWIG_IsOK(res1)) {
20112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20113 }
20114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20115 if (obj1) {
20116 ecode2 = SWIG_AsVal_int(obj1, &val2);
20117 if (!SWIG_IsOK(ecode2)) {
20118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20119 }
20120 arg2 = static_cast< int >(val2);
20121 }
20122 {
20123 PyThreadState* __tstate = wxPyBeginAllowThreads();
20124 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 {
20129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20138 PyObject *resultobj = 0;
20139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20140 int arg2 = (int) wxMOUSE_BTN_ANY ;
20141 bool result;
20142 void *argp1 = 0 ;
20143 int res1 = 0 ;
20144 int val2 ;
20145 int ecode2 = 0 ;
20146 PyObject * obj0 = 0 ;
20147 PyObject * obj1 = 0 ;
20148 char * kwnames[] = {
20149 (char *) "self",(char *) "but", NULL
20150 };
20151
20152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20154 if (!SWIG_IsOK(res1)) {
20155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20156 }
20157 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20158 if (obj1) {
20159 ecode2 = SWIG_AsVal_int(obj1, &val2);
20160 if (!SWIG_IsOK(ecode2)) {
20161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20162 }
20163 arg2 = static_cast< int >(val2);
20164 }
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20168 wxPyEndAllowThreads(__tstate);
20169 if (PyErr_Occurred()) SWIG_fail;
20170 }
20171 {
20172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20173 }
20174 return resultobj;
20175 fail:
20176 return NULL;
20177 }
20178
20179
20180 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20181 PyObject *resultobj = 0;
20182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20183 int arg2 ;
20184 bool result;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 int val2 ;
20188 int ecode2 = 0 ;
20189 PyObject * obj0 = 0 ;
20190 PyObject * obj1 = 0 ;
20191 char * kwnames[] = {
20192 (char *) "self",(char *) "button", NULL
20193 };
20194
20195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20197 if (!SWIG_IsOK(res1)) {
20198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20199 }
20200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20201 ecode2 = SWIG_AsVal_int(obj1, &val2);
20202 if (!SWIG_IsOK(ecode2)) {
20203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20204 }
20205 arg2 = static_cast< int >(val2);
20206 {
20207 PyThreadState* __tstate = wxPyBeginAllowThreads();
20208 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20209 wxPyEndAllowThreads(__tstate);
20210 if (PyErr_Occurred()) SWIG_fail;
20211 }
20212 {
20213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20214 }
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj = 0;
20223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20224 int arg2 ;
20225 bool result;
20226 void *argp1 = 0 ;
20227 int res1 = 0 ;
20228 int val2 ;
20229 int ecode2 = 0 ;
20230 PyObject * obj0 = 0 ;
20231 PyObject * obj1 = 0 ;
20232 char * kwnames[] = {
20233 (char *) "self",(char *) "but", NULL
20234 };
20235
20236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20238 if (!SWIG_IsOK(res1)) {
20239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20240 }
20241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20242 ecode2 = SWIG_AsVal_int(obj1, &val2);
20243 if (!SWIG_IsOK(ecode2)) {
20244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20245 }
20246 arg2 = static_cast< int >(val2);
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 {
20254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20255 }
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20263 PyObject *resultobj = 0;
20264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20265 int result;
20266 void *argp1 = 0 ;
20267 int res1 = 0 ;
20268 PyObject *swig_obj[1] ;
20269
20270 if (!args) SWIG_fail;
20271 swig_obj[0] = args;
20272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20273 if (!SWIG_IsOK(res1)) {
20274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20275 }
20276 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20280 wxPyEndAllowThreads(__tstate);
20281 if (PyErr_Occurred()) SWIG_fail;
20282 }
20283 resultobj = SWIG_From_int(static_cast< int >(result));
20284 return resultobj;
20285 fail:
20286 return NULL;
20287 }
20288
20289
20290 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20291 PyObject *resultobj = 0;
20292 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20293 bool result;
20294 void *argp1 = 0 ;
20295 int res1 = 0 ;
20296 PyObject *swig_obj[1] ;
20297
20298 if (!args) SWIG_fail;
20299 swig_obj[0] = args;
20300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20301 if (!SWIG_IsOK(res1)) {
20302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20303 }
20304 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 {
20312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20313 }
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *resultobj = 0;
20322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20323 bool result;
20324 void *argp1 = 0 ;
20325 int res1 = 0 ;
20326 PyObject *swig_obj[1] ;
20327
20328 if (!args) SWIG_fail;
20329 swig_obj[0] = args;
20330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20331 if (!SWIG_IsOK(res1)) {
20332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20333 }
20334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20338 wxPyEndAllowThreads(__tstate);
20339 if (PyErr_Occurred()) SWIG_fail;
20340 }
20341 {
20342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20343 }
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20351 PyObject *resultobj = 0;
20352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20353 bool result;
20354 void *argp1 = 0 ;
20355 int res1 = 0 ;
20356 PyObject *swig_obj[1] ;
20357
20358 if (!args) SWIG_fail;
20359 swig_obj[0] = args;
20360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20361 if (!SWIG_IsOK(res1)) {
20362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20363 }
20364 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 {
20372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20373 }
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20381 PyObject *resultobj = 0;
20382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20383 bool result;
20384 void *argp1 = 0 ;
20385 int res1 = 0 ;
20386 PyObject *swig_obj[1] ;
20387
20388 if (!args) SWIG_fail;
20389 swig_obj[0] = args;
20390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20391 if (!SWIG_IsOK(res1)) {
20392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20393 }
20394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 {
20402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20403 }
20404 return resultobj;
20405 fail:
20406 return NULL;
20407 }
20408
20409
20410 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20411 PyObject *resultobj = 0;
20412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20413 bool result;
20414 void *argp1 = 0 ;
20415 int res1 = 0 ;
20416 PyObject *swig_obj[1] ;
20417
20418 if (!args) SWIG_fail;
20419 swig_obj[0] = args;
20420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20421 if (!SWIG_IsOK(res1)) {
20422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20423 }
20424 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 {
20432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20433 }
20434 return resultobj;
20435 fail:
20436 return NULL;
20437 }
20438
20439
20440 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20441 PyObject *resultobj = 0;
20442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20443 bool result;
20444 void *argp1 = 0 ;
20445 int res1 = 0 ;
20446 PyObject *swig_obj[1] ;
20447
20448 if (!args) SWIG_fail;
20449 swig_obj[0] = args;
20450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20451 if (!SWIG_IsOK(res1)) {
20452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20453 }
20454 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20458 wxPyEndAllowThreads(__tstate);
20459 if (PyErr_Occurred()) SWIG_fail;
20460 }
20461 {
20462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20463 }
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20471 PyObject *resultobj = 0;
20472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20473 bool result;
20474 void *argp1 = 0 ;
20475 int res1 = 0 ;
20476 PyObject *swig_obj[1] ;
20477
20478 if (!args) SWIG_fail;
20479 swig_obj[0] = args;
20480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20481 if (!SWIG_IsOK(res1)) {
20482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20483 }
20484 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20485 {
20486 PyThreadState* __tstate = wxPyBeginAllowThreads();
20487 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 {
20492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20493 }
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20501 PyObject *resultobj = 0;
20502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20503 bool result;
20504 void *argp1 = 0 ;
20505 int res1 = 0 ;
20506 PyObject *swig_obj[1] ;
20507
20508 if (!args) SWIG_fail;
20509 swig_obj[0] = args;
20510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20511 if (!SWIG_IsOK(res1)) {
20512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20513 }
20514 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 {
20522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20523 }
20524 return resultobj;
20525 fail:
20526 return NULL;
20527 }
20528
20529
20530 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20531 PyObject *resultobj = 0;
20532 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20533 bool result;
20534 void *argp1 = 0 ;
20535 int res1 = 0 ;
20536 PyObject *swig_obj[1] ;
20537
20538 if (!args) SWIG_fail;
20539 swig_obj[0] = args;
20540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20541 if (!SWIG_IsOK(res1)) {
20542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20543 }
20544 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20545 {
20546 PyThreadState* __tstate = wxPyBeginAllowThreads();
20547 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20548 wxPyEndAllowThreads(__tstate);
20549 if (PyErr_Occurred()) SWIG_fail;
20550 }
20551 {
20552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20553 }
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20561 PyObject *resultobj = 0;
20562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20563 bool result;
20564 void *argp1 = 0 ;
20565 int res1 = 0 ;
20566 PyObject *swig_obj[1] ;
20567
20568 if (!args) SWIG_fail;
20569 swig_obj[0] = args;
20570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20571 if (!SWIG_IsOK(res1)) {
20572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20573 }
20574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20575 {
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20578 wxPyEndAllowThreads(__tstate);
20579 if (PyErr_Occurred()) SWIG_fail;
20580 }
20581 {
20582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20583 }
20584 return resultobj;
20585 fail:
20586 return NULL;
20587 }
20588
20589
20590 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20591 PyObject *resultobj = 0;
20592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20593 bool result;
20594 void *argp1 = 0 ;
20595 int res1 = 0 ;
20596 PyObject *swig_obj[1] ;
20597
20598 if (!args) SWIG_fail;
20599 swig_obj[0] = args;
20600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20601 if (!SWIG_IsOK(res1)) {
20602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20603 }
20604 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20605 {
20606 PyThreadState* __tstate = wxPyBeginAllowThreads();
20607 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20608 wxPyEndAllowThreads(__tstate);
20609 if (PyErr_Occurred()) SWIG_fail;
20610 }
20611 {
20612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20613 }
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20621 PyObject *resultobj = 0;
20622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20623 bool result;
20624 void *argp1 = 0 ;
20625 int res1 = 0 ;
20626 PyObject *swig_obj[1] ;
20627
20628 if (!args) SWIG_fail;
20629 swig_obj[0] = args;
20630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20631 if (!SWIG_IsOK(res1)) {
20632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20633 }
20634 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20635 {
20636 PyThreadState* __tstate = wxPyBeginAllowThreads();
20637 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 {
20642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20643 }
20644 return resultobj;
20645 fail:
20646 return NULL;
20647 }
20648
20649
20650 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20651 PyObject *resultobj = 0;
20652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20653 bool result;
20654 void *argp1 = 0 ;
20655 int res1 = 0 ;
20656 PyObject *swig_obj[1] ;
20657
20658 if (!args) SWIG_fail;
20659 swig_obj[0] = args;
20660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20661 if (!SWIG_IsOK(res1)) {
20662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20663 }
20664 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20665 {
20666 PyThreadState* __tstate = wxPyBeginAllowThreads();
20667 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 {
20672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20673 }
20674 return resultobj;
20675 fail:
20676 return NULL;
20677 }
20678
20679
20680 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20681 PyObject *resultobj = 0;
20682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20683 bool result;
20684 void *argp1 = 0 ;
20685 int res1 = 0 ;
20686 PyObject *swig_obj[1] ;
20687
20688 if (!args) SWIG_fail;
20689 swig_obj[0] = args;
20690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20691 if (!SWIG_IsOK(res1)) {
20692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20693 }
20694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 {
20702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20703 }
20704 return resultobj;
20705 fail:
20706 return NULL;
20707 }
20708
20709
20710 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20711 PyObject *resultobj = 0;
20712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20713 bool result;
20714 void *argp1 = 0 ;
20715 int res1 = 0 ;
20716 PyObject *swig_obj[1] ;
20717
20718 if (!args) SWIG_fail;
20719 swig_obj[0] = args;
20720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20721 if (!SWIG_IsOK(res1)) {
20722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20723 }
20724 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20725 {
20726 PyThreadState* __tstate = wxPyBeginAllowThreads();
20727 result = (bool)(arg1)->LeftIsDown();
20728 wxPyEndAllowThreads(__tstate);
20729 if (PyErr_Occurred()) SWIG_fail;
20730 }
20731 {
20732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20733 }
20734 return resultobj;
20735 fail:
20736 return NULL;
20737 }
20738
20739
20740 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20741 PyObject *resultobj = 0;
20742 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20743 bool result;
20744 void *argp1 = 0 ;
20745 int res1 = 0 ;
20746 PyObject *swig_obj[1] ;
20747
20748 if (!args) SWIG_fail;
20749 swig_obj[0] = args;
20750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20751 if (!SWIG_IsOK(res1)) {
20752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20753 }
20754 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (bool)(arg1)->MiddleIsDown();
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 {
20762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20763 }
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20771 PyObject *resultobj = 0;
20772 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20773 bool result;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 PyObject *swig_obj[1] ;
20777
20778 if (!args) SWIG_fail;
20779 swig_obj[0] = args;
20780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20783 }
20784 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (bool)(arg1)->RightIsDown();
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 {
20792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20793 }
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20801 PyObject *resultobj = 0;
20802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20803 bool result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 PyObject *swig_obj[1] ;
20807
20808 if (!args) SWIG_fail;
20809 swig_obj[0] = args;
20810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20811 if (!SWIG_IsOK(res1)) {
20812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20813 }
20814 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 {
20822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20823 }
20824 return resultobj;
20825 fail:
20826 return NULL;
20827 }
20828
20829
20830 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20831 PyObject *resultobj = 0;
20832 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20833 bool result;
20834 void *argp1 = 0 ;
20835 int res1 = 0 ;
20836 PyObject *swig_obj[1] ;
20837
20838 if (!args) SWIG_fail;
20839 swig_obj[0] = args;
20840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20841 if (!SWIG_IsOK(res1)) {
20842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20843 }
20844 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20845 {
20846 PyThreadState* __tstate = wxPyBeginAllowThreads();
20847 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20848 wxPyEndAllowThreads(__tstate);
20849 if (PyErr_Occurred()) SWIG_fail;
20850 }
20851 {
20852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20853 }
20854 return resultobj;
20855 fail:
20856 return NULL;
20857 }
20858
20859
20860 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20861 PyObject *resultobj = 0;
20862 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20863 bool result;
20864 void *argp1 = 0 ;
20865 int res1 = 0 ;
20866 PyObject *swig_obj[1] ;
20867
20868 if (!args) SWIG_fail;
20869 swig_obj[0] = args;
20870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20871 if (!SWIG_IsOK(res1)) {
20872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20873 }
20874 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20883 }
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20891 PyObject *resultobj = 0;
20892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20893 bool result;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 PyObject *swig_obj[1] ;
20897
20898 if (!args) SWIG_fail;
20899 swig_obj[0] = args;
20900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20901 if (!SWIG_IsOK(res1)) {
20902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20903 }
20904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20908 wxPyEndAllowThreads(__tstate);
20909 if (PyErr_Occurred()) SWIG_fail;
20910 }
20911 {
20912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20913 }
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 PyObject *resultobj = 0;
20922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20923 wxPoint result;
20924 void *argp1 = 0 ;
20925 int res1 = 0 ;
20926 PyObject *swig_obj[1] ;
20927
20928 if (!args) SWIG_fail;
20929 swig_obj[0] = args;
20930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20931 if (!SWIG_IsOK(res1)) {
20932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20933 }
20934 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (arg1)->GetPosition();
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 long *arg2 = (long *) 0 ;
20952 long *arg3 = (long *) 0 ;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 long temp2 ;
20956 int res2 = SWIG_TMPOBJ ;
20957 long temp3 ;
20958 int res3 = SWIG_TMPOBJ ;
20959 PyObject *swig_obj[1] ;
20960
20961 arg2 = &temp2;
20962 arg3 = &temp3;
20963 if (!args) SWIG_fail;
20964 swig_obj[0] = args;
20965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20966 if (!SWIG_IsOK(res1)) {
20967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20968 }
20969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20970 {
20971 PyThreadState* __tstate = wxPyBeginAllowThreads();
20972 (arg1)->GetPosition(arg2,arg3);
20973 wxPyEndAllowThreads(__tstate);
20974 if (PyErr_Occurred()) SWIG_fail;
20975 }
20976 resultobj = SWIG_Py_Void();
20977 if (SWIG_IsTmpObj(res2)) {
20978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20979 } else {
20980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20982 }
20983 if (SWIG_IsTmpObj(res3)) {
20984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20985 } else {
20986 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20988 }
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj = 0;
20997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20998 wxDC *arg2 = 0 ;
20999 wxPoint result;
21000 void *argp1 = 0 ;
21001 int res1 = 0 ;
21002 void *argp2 = 0 ;
21003 int res2 = 0 ;
21004 PyObject * obj0 = 0 ;
21005 PyObject * obj1 = 0 ;
21006 char * kwnames[] = {
21007 (char *) "self",(char *) "dc", NULL
21008 };
21009
21010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21012 if (!SWIG_IsOK(res1)) {
21013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21014 }
21015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21016 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21017 if (!SWIG_IsOK(res2)) {
21018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21019 }
21020 if (!argp2) {
21021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21022 }
21023 arg2 = reinterpret_cast< wxDC * >(argp2);
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21038 PyObject *resultobj = 0;
21039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21040 int result;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 PyObject *swig_obj[1] ;
21044
21045 if (!args) SWIG_fail;
21046 swig_obj[0] = args;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21050 }
21051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (int)((wxMouseEvent const *)arg1)->GetX();
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = SWIG_From_int(static_cast< int >(result));
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21066 PyObject *resultobj = 0;
21067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21068 int result;
21069 void *argp1 = 0 ;
21070 int res1 = 0 ;
21071 PyObject *swig_obj[1] ;
21072
21073 if (!args) SWIG_fail;
21074 swig_obj[0] = args;
21075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21076 if (!SWIG_IsOK(res1)) {
21077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21078 }
21079 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 result = (int)((wxMouseEvent const *)arg1)->GetY();
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 resultobj = SWIG_From_int(static_cast< int >(result));
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21094 PyObject *resultobj = 0;
21095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21096 int result;
21097 void *argp1 = 0 ;
21098 int res1 = 0 ;
21099 PyObject *swig_obj[1] ;
21100
21101 if (!args) SWIG_fail;
21102 swig_obj[0] = args;
21103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21104 if (!SWIG_IsOK(res1)) {
21105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21106 }
21107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21108 {
21109 PyThreadState* __tstate = wxPyBeginAllowThreads();
21110 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21111 wxPyEndAllowThreads(__tstate);
21112 if (PyErr_Occurred()) SWIG_fail;
21113 }
21114 resultobj = SWIG_From_int(static_cast< int >(result));
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21122 PyObject *resultobj = 0;
21123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21124 int result;
21125 void *argp1 = 0 ;
21126 int res1 = 0 ;
21127 PyObject *swig_obj[1] ;
21128
21129 if (!args) SWIG_fail;
21130 swig_obj[0] = args;
21131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21132 if (!SWIG_IsOK(res1)) {
21133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21134 }
21135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21139 wxPyEndAllowThreads(__tstate);
21140 if (PyErr_Occurred()) SWIG_fail;
21141 }
21142 resultobj = SWIG_From_int(static_cast< int >(result));
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21150 PyObject *resultobj = 0;
21151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21152 int result;
21153 void *argp1 = 0 ;
21154 int res1 = 0 ;
21155 PyObject *swig_obj[1] ;
21156
21157 if (!args) SWIG_fail;
21158 swig_obj[0] = args;
21159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21160 if (!SWIG_IsOK(res1)) {
21161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21162 }
21163 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21164 {
21165 PyThreadState* __tstate = wxPyBeginAllowThreads();
21166 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21167 wxPyEndAllowThreads(__tstate);
21168 if (PyErr_Occurred()) SWIG_fail;
21169 }
21170 resultobj = SWIG_From_int(static_cast< int >(result));
21171 return resultobj;
21172 fail:
21173 return NULL;
21174 }
21175
21176
21177 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21178 PyObject *resultobj = 0;
21179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21180 bool result;
21181 void *argp1 = 0 ;
21182 int res1 = 0 ;
21183 PyObject *swig_obj[1] ;
21184
21185 if (!args) SWIG_fail;
21186 swig_obj[0] = args;
21187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21188 if (!SWIG_IsOK(res1)) {
21189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21190 }
21191 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21192 {
21193 PyThreadState* __tstate = wxPyBeginAllowThreads();
21194 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21195 wxPyEndAllowThreads(__tstate);
21196 if (PyErr_Occurred()) SWIG_fail;
21197 }
21198 {
21199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21200 }
21201 return resultobj;
21202 fail:
21203 return NULL;
21204 }
21205
21206
21207 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21208 PyObject *resultobj = 0;
21209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21210 int arg2 ;
21211 void *argp1 = 0 ;
21212 int res1 = 0 ;
21213 int val2 ;
21214 int ecode2 = 0 ;
21215 PyObject *swig_obj[2] ;
21216
21217 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21219 if (!SWIG_IsOK(res1)) {
21220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21221 }
21222 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21223 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21224 if (!SWIG_IsOK(ecode2)) {
21225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21226 }
21227 arg2 = static_cast< int >(val2);
21228 if (arg1) (arg1)->m_x = arg2;
21229
21230 resultobj = SWIG_Py_Void();
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21238 PyObject *resultobj = 0;
21239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21240 int result;
21241 void *argp1 = 0 ;
21242 int res1 = 0 ;
21243 PyObject *swig_obj[1] ;
21244
21245 if (!args) SWIG_fail;
21246 swig_obj[0] = args;
21247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21248 if (!SWIG_IsOK(res1)) {
21249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21250 }
21251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21252 result = (int) ((arg1)->m_x);
21253 resultobj = SWIG_From_int(static_cast< int >(result));
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21261 PyObject *resultobj = 0;
21262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21263 int arg2 ;
21264 void *argp1 = 0 ;
21265 int res1 = 0 ;
21266 int val2 ;
21267 int ecode2 = 0 ;
21268 PyObject *swig_obj[2] ;
21269
21270 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21272 if (!SWIG_IsOK(res1)) {
21273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21274 }
21275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21276 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21277 if (!SWIG_IsOK(ecode2)) {
21278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21279 }
21280 arg2 = static_cast< int >(val2);
21281 if (arg1) (arg1)->m_y = arg2;
21282
21283 resultobj = SWIG_Py_Void();
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21291 PyObject *resultobj = 0;
21292 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21293 int result;
21294 void *argp1 = 0 ;
21295 int res1 = 0 ;
21296 PyObject *swig_obj[1] ;
21297
21298 if (!args) SWIG_fail;
21299 swig_obj[0] = args;
21300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21303 }
21304 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21305 result = (int) ((arg1)->m_y);
21306 resultobj = SWIG_From_int(static_cast< int >(result));
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314 PyObject *resultobj = 0;
21315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21316 bool arg2 ;
21317 void *argp1 = 0 ;
21318 int res1 = 0 ;
21319 bool val2 ;
21320 int ecode2 = 0 ;
21321 PyObject *swig_obj[2] ;
21322
21323 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21327 }
21328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21329 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21330 if (!SWIG_IsOK(ecode2)) {
21331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21332 }
21333 arg2 = static_cast< bool >(val2);
21334 if (arg1) (arg1)->m_leftDown = arg2;
21335
21336 resultobj = SWIG_Py_Void();
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344 PyObject *resultobj = 0;
21345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21346 bool result;
21347 void *argp1 = 0 ;
21348 int res1 = 0 ;
21349 PyObject *swig_obj[1] ;
21350
21351 if (!args) SWIG_fail;
21352 swig_obj[0] = args;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21358 result = (bool) ((arg1)->m_leftDown);
21359 {
21360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21361 }
21362 return resultobj;
21363 fail:
21364 return NULL;
21365 }
21366
21367
21368 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21369 PyObject *resultobj = 0;
21370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21371 bool arg2 ;
21372 void *argp1 = 0 ;
21373 int res1 = 0 ;
21374 bool val2 ;
21375 int ecode2 = 0 ;
21376 PyObject *swig_obj[2] ;
21377
21378 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21380 if (!SWIG_IsOK(res1)) {
21381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21382 }
21383 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21384 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21385 if (!SWIG_IsOK(ecode2)) {
21386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21387 }
21388 arg2 = static_cast< bool >(val2);
21389 if (arg1) (arg1)->m_middleDown = arg2;
21390
21391 resultobj = SWIG_Py_Void();
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21399 PyObject *resultobj = 0;
21400 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21401 bool result;
21402 void *argp1 = 0 ;
21403 int res1 = 0 ;
21404 PyObject *swig_obj[1] ;
21405
21406 if (!args) SWIG_fail;
21407 swig_obj[0] = args;
21408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21409 if (!SWIG_IsOK(res1)) {
21410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21411 }
21412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21413 result = (bool) ((arg1)->m_middleDown);
21414 {
21415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21416 }
21417 return resultobj;
21418 fail:
21419 return NULL;
21420 }
21421
21422
21423 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21424 PyObject *resultobj = 0;
21425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21426 bool arg2 ;
21427 void *argp1 = 0 ;
21428 int res1 = 0 ;
21429 bool val2 ;
21430 int ecode2 = 0 ;
21431 PyObject *swig_obj[2] ;
21432
21433 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21435 if (!SWIG_IsOK(res1)) {
21436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21437 }
21438 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21439 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21440 if (!SWIG_IsOK(ecode2)) {
21441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21442 }
21443 arg2 = static_cast< bool >(val2);
21444 if (arg1) (arg1)->m_rightDown = arg2;
21445
21446 resultobj = SWIG_Py_Void();
21447 return resultobj;
21448 fail:
21449 return NULL;
21450 }
21451
21452
21453 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21454 PyObject *resultobj = 0;
21455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21456 bool result;
21457 void *argp1 = 0 ;
21458 int res1 = 0 ;
21459 PyObject *swig_obj[1] ;
21460
21461 if (!args) SWIG_fail;
21462 swig_obj[0] = args;
21463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21464 if (!SWIG_IsOK(res1)) {
21465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21466 }
21467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21468 result = (bool) ((arg1)->m_rightDown);
21469 {
21470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21471 }
21472 return resultobj;
21473 fail:
21474 return NULL;
21475 }
21476
21477
21478 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21479 PyObject *resultobj = 0;
21480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21481 bool arg2 ;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 bool val2 ;
21485 int ecode2 = 0 ;
21486 PyObject *swig_obj[2] ;
21487
21488 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21490 if (!SWIG_IsOK(res1)) {
21491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21492 }
21493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21494 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21495 if (!SWIG_IsOK(ecode2)) {
21496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21497 }
21498 arg2 = static_cast< bool >(val2);
21499 if (arg1) (arg1)->m_controlDown = arg2;
21500
21501 resultobj = SWIG_Py_Void();
21502 return resultobj;
21503 fail:
21504 return NULL;
21505 }
21506
21507
21508 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21509 PyObject *resultobj = 0;
21510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21511 bool result;
21512 void *argp1 = 0 ;
21513 int res1 = 0 ;
21514 PyObject *swig_obj[1] ;
21515
21516 if (!args) SWIG_fail;
21517 swig_obj[0] = args;
21518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21519 if (!SWIG_IsOK(res1)) {
21520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21521 }
21522 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21523 result = (bool) ((arg1)->m_controlDown);
21524 {
21525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21526 }
21527 return resultobj;
21528 fail:
21529 return NULL;
21530 }
21531
21532
21533 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21534 PyObject *resultobj = 0;
21535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21536 bool arg2 ;
21537 void *argp1 = 0 ;
21538 int res1 = 0 ;
21539 bool val2 ;
21540 int ecode2 = 0 ;
21541 PyObject *swig_obj[2] ;
21542
21543 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21545 if (!SWIG_IsOK(res1)) {
21546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21547 }
21548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21549 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21550 if (!SWIG_IsOK(ecode2)) {
21551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21552 }
21553 arg2 = static_cast< bool >(val2);
21554 if (arg1) (arg1)->m_shiftDown = arg2;
21555
21556 resultobj = SWIG_Py_Void();
21557 return resultobj;
21558 fail:
21559 return NULL;
21560 }
21561
21562
21563 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21564 PyObject *resultobj = 0;
21565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21566 bool result;
21567 void *argp1 = 0 ;
21568 int res1 = 0 ;
21569 PyObject *swig_obj[1] ;
21570
21571 if (!args) SWIG_fail;
21572 swig_obj[0] = args;
21573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21574 if (!SWIG_IsOK(res1)) {
21575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21576 }
21577 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21578 result = (bool) ((arg1)->m_shiftDown);
21579 {
21580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21581 }
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 bool arg2 ;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 bool val2 ;
21595 int ecode2 = 0 ;
21596 PyObject *swig_obj[2] ;
21597
21598 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21600 if (!SWIG_IsOK(res1)) {
21601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21602 }
21603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21604 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21605 if (!SWIG_IsOK(ecode2)) {
21606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21607 }
21608 arg2 = static_cast< bool >(val2);
21609 if (arg1) (arg1)->m_altDown = arg2;
21610
21611 resultobj = SWIG_Py_Void();
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 PyObject *resultobj = 0;
21620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21621 bool result;
21622 void *argp1 = 0 ;
21623 int res1 = 0 ;
21624 PyObject *swig_obj[1] ;
21625
21626 if (!args) SWIG_fail;
21627 swig_obj[0] = args;
21628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21629 if (!SWIG_IsOK(res1)) {
21630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21631 }
21632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21633 result = (bool) ((arg1)->m_altDown);
21634 {
21635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21636 }
21637 return resultobj;
21638 fail:
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21644 PyObject *resultobj = 0;
21645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21646 bool arg2 ;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 bool val2 ;
21650 int ecode2 = 0 ;
21651 PyObject *swig_obj[2] ;
21652
21653 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21657 }
21658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21659 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21660 if (!SWIG_IsOK(ecode2)) {
21661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21662 }
21663 arg2 = static_cast< bool >(val2);
21664 if (arg1) (arg1)->m_metaDown = arg2;
21665
21666 resultobj = SWIG_Py_Void();
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 PyObject *resultobj = 0;
21675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21676 bool result;
21677 void *argp1 = 0 ;
21678 int res1 = 0 ;
21679 PyObject *swig_obj[1] ;
21680
21681 if (!args) SWIG_fail;
21682 swig_obj[0] = args;
21683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21684 if (!SWIG_IsOK(res1)) {
21685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21686 }
21687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21688 result = (bool) ((arg1)->m_metaDown);
21689 {
21690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21691 }
21692 return resultobj;
21693 fail:
21694 return NULL;
21695 }
21696
21697
21698 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21699 PyObject *resultobj = 0;
21700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21701 int arg2 ;
21702 void *argp1 = 0 ;
21703 int res1 = 0 ;
21704 int val2 ;
21705 int ecode2 = 0 ;
21706 PyObject *swig_obj[2] ;
21707
21708 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21710 if (!SWIG_IsOK(res1)) {
21711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21712 }
21713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21714 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21715 if (!SWIG_IsOK(ecode2)) {
21716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21717 }
21718 arg2 = static_cast< int >(val2);
21719 if (arg1) (arg1)->m_wheelRotation = arg2;
21720
21721 resultobj = SWIG_Py_Void();
21722 return resultobj;
21723 fail:
21724 return NULL;
21725 }
21726
21727
21728 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21729 PyObject *resultobj = 0;
21730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21731 int result;
21732 void *argp1 = 0 ;
21733 int res1 = 0 ;
21734 PyObject *swig_obj[1] ;
21735
21736 if (!args) SWIG_fail;
21737 swig_obj[0] = args;
21738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21739 if (!SWIG_IsOK(res1)) {
21740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21741 }
21742 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21743 result = (int) ((arg1)->m_wheelRotation);
21744 resultobj = SWIG_From_int(static_cast< int >(result));
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21752 PyObject *resultobj = 0;
21753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21754 int arg2 ;
21755 void *argp1 = 0 ;
21756 int res1 = 0 ;
21757 int val2 ;
21758 int ecode2 = 0 ;
21759 PyObject *swig_obj[2] ;
21760
21761 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21763 if (!SWIG_IsOK(res1)) {
21764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21765 }
21766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21767 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21768 if (!SWIG_IsOK(ecode2)) {
21769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21770 }
21771 arg2 = static_cast< int >(val2);
21772 if (arg1) (arg1)->m_wheelDelta = arg2;
21773
21774 resultobj = SWIG_Py_Void();
21775 return resultobj;
21776 fail:
21777 return NULL;
21778 }
21779
21780
21781 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21782 PyObject *resultobj = 0;
21783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21784 int result;
21785 void *argp1 = 0 ;
21786 int res1 = 0 ;
21787 PyObject *swig_obj[1] ;
21788
21789 if (!args) SWIG_fail;
21790 swig_obj[0] = args;
21791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21794 }
21795 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21796 result = (int) ((arg1)->m_wheelDelta);
21797 resultobj = SWIG_From_int(static_cast< int >(result));
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21805 PyObject *resultobj = 0;
21806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21807 int arg2 ;
21808 void *argp1 = 0 ;
21809 int res1 = 0 ;
21810 int val2 ;
21811 int ecode2 = 0 ;
21812 PyObject *swig_obj[2] ;
21813
21814 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21816 if (!SWIG_IsOK(res1)) {
21817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21818 }
21819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21820 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21821 if (!SWIG_IsOK(ecode2)) {
21822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21823 }
21824 arg2 = static_cast< int >(val2);
21825 if (arg1) (arg1)->m_linesPerAction = arg2;
21826
21827 resultobj = SWIG_Py_Void();
21828 return resultobj;
21829 fail:
21830 return NULL;
21831 }
21832
21833
21834 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21835 PyObject *resultobj = 0;
21836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21837 int result;
21838 void *argp1 = 0 ;
21839 int res1 = 0 ;
21840 PyObject *swig_obj[1] ;
21841
21842 if (!args) SWIG_fail;
21843 swig_obj[0] = args;
21844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21845 if (!SWIG_IsOK(res1)) {
21846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21847 }
21848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21849 result = (int) ((arg1)->m_linesPerAction);
21850 resultobj = SWIG_From_int(static_cast< int >(result));
21851 return resultobj;
21852 fail:
21853 return NULL;
21854 }
21855
21856
21857 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21858 PyObject *obj;
21859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21860 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21861 return SWIG_Py_Void();
21862 }
21863
21864 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21865 return SWIG_Python_InitShadowInstance(args);
21866 }
21867
21868 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21869 PyObject *resultobj = 0;
21870 int arg1 = (int) 0 ;
21871 int arg2 = (int) 0 ;
21872 wxSetCursorEvent *result = 0 ;
21873 int val1 ;
21874 int ecode1 = 0 ;
21875 int val2 ;
21876 int ecode2 = 0 ;
21877 PyObject * obj0 = 0 ;
21878 PyObject * obj1 = 0 ;
21879 char * kwnames[] = {
21880 (char *) "x",(char *) "y", NULL
21881 };
21882
21883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21884 if (obj0) {
21885 ecode1 = SWIG_AsVal_int(obj0, &val1);
21886 if (!SWIG_IsOK(ecode1)) {
21887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21888 }
21889 arg1 = static_cast< int >(val1);
21890 }
21891 if (obj1) {
21892 ecode2 = SWIG_AsVal_int(obj1, &val2);
21893 if (!SWIG_IsOK(ecode2)) {
21894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21895 }
21896 arg2 = static_cast< int >(val2);
21897 }
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21905 return resultobj;
21906 fail:
21907 return NULL;
21908 }
21909
21910
21911 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21912 PyObject *resultobj = 0;
21913 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21914 int result;
21915 void *argp1 = 0 ;
21916 int res1 = 0 ;
21917 PyObject *swig_obj[1] ;
21918
21919 if (!args) SWIG_fail;
21920 swig_obj[0] = args;
21921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21922 if (!SWIG_IsOK(res1)) {
21923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21924 }
21925 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 resultobj = SWIG_From_int(static_cast< int >(result));
21933 return resultobj;
21934 fail:
21935 return NULL;
21936 }
21937
21938
21939 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21940 PyObject *resultobj = 0;
21941 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21942 int result;
21943 void *argp1 = 0 ;
21944 int res1 = 0 ;
21945 PyObject *swig_obj[1] ;
21946
21947 if (!args) SWIG_fail;
21948 swig_obj[0] = args;
21949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21950 if (!SWIG_IsOK(res1)) {
21951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21952 }
21953 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 resultobj = SWIG_From_int(static_cast< int >(result));
21961 return resultobj;
21962 fail:
21963 return NULL;
21964 }
21965
21966
21967 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj = 0;
21969 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21970 wxCursor *arg2 = 0 ;
21971 void *argp1 = 0 ;
21972 int res1 = 0 ;
21973 void *argp2 = 0 ;
21974 int res2 = 0 ;
21975 PyObject * obj0 = 0 ;
21976 PyObject * obj1 = 0 ;
21977 char * kwnames[] = {
21978 (char *) "self",(char *) "cursor", NULL
21979 };
21980
21981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21985 }
21986 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21988 if (!SWIG_IsOK(res2)) {
21989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21990 }
21991 if (!argp2) {
21992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21993 }
21994 arg2 = reinterpret_cast< wxCursor * >(argp2);
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 (arg1)->SetCursor((wxCursor const &)*arg2);
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 resultobj = SWIG_Py_Void();
22002 return resultobj;
22003 fail:
22004 return NULL;
22005 }
22006
22007
22008 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22009 PyObject *resultobj = 0;
22010 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22011 wxCursor *result = 0 ;
22012 void *argp1 = 0 ;
22013 int res1 = 0 ;
22014 PyObject *swig_obj[1] ;
22015
22016 if (!args) SWIG_fail;
22017 swig_obj[0] = args;
22018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22019 if (!SWIG_IsOK(res1)) {
22020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22021 }
22022 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22023 {
22024 PyThreadState* __tstate = wxPyBeginAllowThreads();
22025 {
22026 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22027 result = (wxCursor *) &_result_ref;
22028 }
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 {
22033 wxCursor* resultptr = new wxCursor(*result);
22034 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22035 }
22036 return resultobj;
22037 fail:
22038 return NULL;
22039 }
22040
22041
22042 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22043 PyObject *resultobj = 0;
22044 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22045 bool result;
22046 void *argp1 = 0 ;
22047 int res1 = 0 ;
22048 PyObject *swig_obj[1] ;
22049
22050 if (!args) SWIG_fail;
22051 swig_obj[0] = args;
22052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22053 if (!SWIG_IsOK(res1)) {
22054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22055 }
22056 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 {
22064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22065 }
22066 return resultobj;
22067 fail:
22068 return NULL;
22069 }
22070
22071
22072 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22073 PyObject *obj;
22074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22075 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22076 return SWIG_Py_Void();
22077 }
22078
22079 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22080 return SWIG_Python_InitShadowInstance(args);
22081 }
22082
22083 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj = 0;
22085 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22086 wxKeyEvent *result = 0 ;
22087 int val1 ;
22088 int ecode1 = 0 ;
22089 PyObject * obj0 = 0 ;
22090 char * kwnames[] = {
22091 (char *) "eventType", NULL
22092 };
22093
22094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22095 if (obj0) {
22096 ecode1 = SWIG_AsVal_int(obj0, &val1);
22097 if (!SWIG_IsOK(ecode1)) {
22098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22099 }
22100 arg1 = static_cast< wxEventType >(val1);
22101 }
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22109 return resultobj;
22110 fail:
22111 return NULL;
22112 }
22113
22114
22115 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22116 PyObject *resultobj = 0;
22117 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22118 int result;
22119 void *argp1 = 0 ;
22120 int res1 = 0 ;
22121 PyObject *swig_obj[1] ;
22122
22123 if (!args) SWIG_fail;
22124 swig_obj[0] = args;
22125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22126 if (!SWIG_IsOK(res1)) {
22127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22128 }
22129 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22133 wxPyEndAllowThreads(__tstate);
22134 if (PyErr_Occurred()) SWIG_fail;
22135 }
22136 resultobj = SWIG_From_int(static_cast< int >(result));
22137 return resultobj;
22138 fail:
22139 return NULL;
22140 }
22141
22142
22143 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22144 PyObject *resultobj = 0;
22145 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22146 bool result;
22147 void *argp1 = 0 ;
22148 int res1 = 0 ;
22149 PyObject *swig_obj[1] ;
22150
22151 if (!args) SWIG_fail;
22152 swig_obj[0] = args;
22153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22154 if (!SWIG_IsOK(res1)) {
22155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22156 }
22157 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 {
22165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22166 }
22167 return resultobj;
22168 fail:
22169 return NULL;
22170 }
22171
22172
22173 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22174 PyObject *resultobj = 0;
22175 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22176 bool result;
22177 void *argp1 = 0 ;
22178 int res1 = 0 ;
22179 PyObject *swig_obj[1] ;
22180
22181 if (!args) SWIG_fail;
22182 swig_obj[0] = args;
22183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22184 if (!SWIG_IsOK(res1)) {
22185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22186 }
22187 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22188 {
22189 PyThreadState* __tstate = wxPyBeginAllowThreads();
22190 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 {
22195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22196 }
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22204 PyObject *resultobj = 0;
22205 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22206 bool result;
22207 void *argp1 = 0 ;
22208 int res1 = 0 ;
22209 PyObject *swig_obj[1] ;
22210
22211 if (!args) SWIG_fail;
22212 swig_obj[0] = args;
22213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22214 if (!SWIG_IsOK(res1)) {
22215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22216 }
22217 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22218 {
22219 PyThreadState* __tstate = wxPyBeginAllowThreads();
22220 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 {
22225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22226 }
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22234 PyObject *resultobj = 0;
22235 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22236 bool result;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 PyObject *swig_obj[1] ;
22240
22241 if (!args) SWIG_fail;
22242 swig_obj[0] = args;
22243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22244 if (!SWIG_IsOK(res1)) {
22245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22246 }
22247 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22248 {
22249 PyThreadState* __tstate = wxPyBeginAllowThreads();
22250 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 {
22255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22264 PyObject *resultobj = 0;
22265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22266 bool result;
22267 void *argp1 = 0 ;
22268 int res1 = 0 ;
22269 PyObject *swig_obj[1] ;
22270
22271 if (!args) SWIG_fail;
22272 swig_obj[0] = args;
22273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22274 if (!SWIG_IsOK(res1)) {
22275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22276 }
22277 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22281 wxPyEndAllowThreads(__tstate);
22282 if (PyErr_Occurred()) SWIG_fail;
22283 }
22284 {
22285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22286 }
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22294 PyObject *resultobj = 0;
22295 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22296 bool result;
22297 void *argp1 = 0 ;
22298 int res1 = 0 ;
22299 PyObject *swig_obj[1] ;
22300
22301 if (!args) SWIG_fail;
22302 swig_obj[0] = args;
22303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22304 if (!SWIG_IsOK(res1)) {
22305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22306 }
22307 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22311 wxPyEndAllowThreads(__tstate);
22312 if (PyErr_Occurred()) SWIG_fail;
22313 }
22314 {
22315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22316 }
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22324 PyObject *resultobj = 0;
22325 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22326 int result;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 PyObject *swig_obj[1] ;
22330
22331 if (!args) SWIG_fail;
22332 swig_obj[0] = args;
22333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22334 if (!SWIG_IsOK(res1)) {
22335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22336 }
22337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22341 wxPyEndAllowThreads(__tstate);
22342 if (PyErr_Occurred()) SWIG_fail;
22343 }
22344 resultobj = SWIG_From_int(static_cast< int >(result));
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22352 PyObject *resultobj = 0;
22353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22354 int result;
22355 void *argp1 = 0 ;
22356 int res1 = 0 ;
22357 PyObject *swig_obj[1] ;
22358
22359 if (!args) SWIG_fail;
22360 swig_obj[0] = args;
22361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22362 if (!SWIG_IsOK(res1)) {
22363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22364 }
22365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 resultobj = SWIG_From_int(static_cast< int >(result));
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj = 0;
22381 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22382 int arg2 ;
22383 void *argp1 = 0 ;
22384 int res1 = 0 ;
22385 int val2 ;
22386 int ecode2 = 0 ;
22387 PyObject * obj0 = 0 ;
22388 PyObject * obj1 = 0 ;
22389 char * kwnames[] = {
22390 (char *) "self",(char *) "uniChar", NULL
22391 };
22392
22393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22395 if (!SWIG_IsOK(res1)) {
22396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22397 }
22398 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22399 ecode2 = SWIG_AsVal_int(obj1, &val2);
22400 if (!SWIG_IsOK(ecode2)) {
22401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22402 }
22403 arg2 = static_cast< int >(val2);
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 resultobj = SWIG_Py_Void();
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22418 PyObject *resultobj = 0;
22419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22420 unsigned int result;
22421 void *argp1 = 0 ;
22422 int res1 = 0 ;
22423 PyObject *swig_obj[1] ;
22424
22425 if (!args) SWIG_fail;
22426 swig_obj[0] = args;
22427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22428 if (!SWIG_IsOK(res1)) {
22429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 unsigned int result;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 PyObject *swig_obj[1] ;
22452
22453 if (!args) SWIG_fail;
22454 swig_obj[0] = args;
22455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22456 if (!SWIG_IsOK(res1)) {
22457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22458 }
22459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22460 {
22461 PyThreadState* __tstate = wxPyBeginAllowThreads();
22462 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22463 wxPyEndAllowThreads(__tstate);
22464 if (PyErr_Occurred()) SWIG_fail;
22465 }
22466 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22476 wxPoint result;
22477 void *argp1 = 0 ;
22478 int res1 = 0 ;
22479 PyObject *swig_obj[1] ;
22480
22481 if (!args) SWIG_fail;
22482 swig_obj[0] = args;
22483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22484 if (!SWIG_IsOK(res1)) {
22485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22486 }
22487 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22488 {
22489 PyThreadState* __tstate = wxPyBeginAllowThreads();
22490 result = (arg1)->GetPosition();
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22495 return resultobj;
22496 fail:
22497 return NULL;
22498 }
22499
22500
22501 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22502 PyObject *resultobj = 0;
22503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22504 long *arg2 = (long *) 0 ;
22505 long *arg3 = (long *) 0 ;
22506 void *argp1 = 0 ;
22507 int res1 = 0 ;
22508 long temp2 ;
22509 int res2 = SWIG_TMPOBJ ;
22510 long temp3 ;
22511 int res3 = SWIG_TMPOBJ ;
22512 PyObject *swig_obj[1] ;
22513
22514 arg2 = &temp2;
22515 arg3 = &temp3;
22516 if (!args) SWIG_fail;
22517 swig_obj[0] = args;
22518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22519 if (!SWIG_IsOK(res1)) {
22520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22521 }
22522 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22523 {
22524 PyThreadState* __tstate = wxPyBeginAllowThreads();
22525 (arg1)->GetPosition(arg2,arg3);
22526 wxPyEndAllowThreads(__tstate);
22527 if (PyErr_Occurred()) SWIG_fail;
22528 }
22529 resultobj = SWIG_Py_Void();
22530 if (SWIG_IsTmpObj(res2)) {
22531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22532 } else {
22533 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22535 }
22536 if (SWIG_IsTmpObj(res3)) {
22537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22538 } else {
22539 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22541 }
22542 return resultobj;
22543 fail:
22544 return NULL;
22545 }
22546
22547
22548 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22549 PyObject *resultobj = 0;
22550 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22551 int result;
22552 void *argp1 = 0 ;
22553 int res1 = 0 ;
22554 PyObject *swig_obj[1] ;
22555
22556 if (!args) SWIG_fail;
22557 swig_obj[0] = args;
22558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22559 if (!SWIG_IsOK(res1)) {
22560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22561 }
22562 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22563 {
22564 PyThreadState* __tstate = wxPyBeginAllowThreads();
22565 result = (int)((wxKeyEvent const *)arg1)->GetX();
22566 wxPyEndAllowThreads(__tstate);
22567 if (PyErr_Occurred()) SWIG_fail;
22568 }
22569 resultobj = SWIG_From_int(static_cast< int >(result));
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22577 PyObject *resultobj = 0;
22578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22579 int result;
22580 void *argp1 = 0 ;
22581 int res1 = 0 ;
22582 PyObject *swig_obj[1] ;
22583
22584 if (!args) SWIG_fail;
22585 swig_obj[0] = args;
22586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22587 if (!SWIG_IsOK(res1)) {
22588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22589 }
22590 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22591 {
22592 PyThreadState* __tstate = wxPyBeginAllowThreads();
22593 result = (int)((wxKeyEvent const *)arg1)->GetY();
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 resultobj = SWIG_From_int(static_cast< int >(result));
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22605 PyObject *resultobj = 0;
22606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22607 int arg2 ;
22608 void *argp1 = 0 ;
22609 int res1 = 0 ;
22610 int val2 ;
22611 int ecode2 = 0 ;
22612 PyObject *swig_obj[2] ;
22613
22614 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22616 if (!SWIG_IsOK(res1)) {
22617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22618 }
22619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22621 if (!SWIG_IsOK(ecode2)) {
22622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22623 }
22624 arg2 = static_cast< int >(val2);
22625 if (arg1) (arg1)->m_x = arg2;
22626
22627 resultobj = SWIG_Py_Void();
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22635 PyObject *resultobj = 0;
22636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22637 int result;
22638 void *argp1 = 0 ;
22639 int res1 = 0 ;
22640 PyObject *swig_obj[1] ;
22641
22642 if (!args) SWIG_fail;
22643 swig_obj[0] = args;
22644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22645 if (!SWIG_IsOK(res1)) {
22646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22647 }
22648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22649 result = (int) ((arg1)->m_x);
22650 resultobj = SWIG_From_int(static_cast< int >(result));
22651 return resultobj;
22652 fail:
22653 return NULL;
22654 }
22655
22656
22657 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22658 PyObject *resultobj = 0;
22659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22660 int arg2 ;
22661 void *argp1 = 0 ;
22662 int res1 = 0 ;
22663 int val2 ;
22664 int ecode2 = 0 ;
22665 PyObject *swig_obj[2] ;
22666
22667 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22671 }
22672 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22674 if (!SWIG_IsOK(ecode2)) {
22675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22676 }
22677 arg2 = static_cast< int >(val2);
22678 if (arg1) (arg1)->m_y = arg2;
22679
22680 resultobj = SWIG_Py_Void();
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22688 PyObject *resultobj = 0;
22689 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22690 int result;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 PyObject *swig_obj[1] ;
22694
22695 if (!args) SWIG_fail;
22696 swig_obj[0] = args;
22697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22698 if (!SWIG_IsOK(res1)) {
22699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22700 }
22701 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22702 result = (int) ((arg1)->m_y);
22703 resultobj = SWIG_From_int(static_cast< int >(result));
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22713 long arg2 ;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 long val2 ;
22717 int ecode2 = 0 ;
22718 PyObject *swig_obj[2] ;
22719
22720 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22722 if (!SWIG_IsOK(res1)) {
22723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22724 }
22725 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22726 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22727 if (!SWIG_IsOK(ecode2)) {
22728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22729 }
22730 arg2 = static_cast< long >(val2);
22731 if (arg1) (arg1)->m_keyCode = arg2;
22732
22733 resultobj = SWIG_Py_Void();
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22741 PyObject *resultobj = 0;
22742 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22743 long result;
22744 void *argp1 = 0 ;
22745 int res1 = 0 ;
22746 PyObject *swig_obj[1] ;
22747
22748 if (!args) SWIG_fail;
22749 swig_obj[0] = args;
22750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22751 if (!SWIG_IsOK(res1)) {
22752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22753 }
22754 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22755 result = (long) ((arg1)->m_keyCode);
22756 resultobj = SWIG_From_long(static_cast< long >(result));
22757 return resultobj;
22758 fail:
22759 return NULL;
22760 }
22761
22762
22763 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22764 PyObject *resultobj = 0;
22765 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22766 bool arg2 ;
22767 void *argp1 = 0 ;
22768 int res1 = 0 ;
22769 bool val2 ;
22770 int ecode2 = 0 ;
22771 PyObject *swig_obj[2] ;
22772
22773 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22775 if (!SWIG_IsOK(res1)) {
22776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22777 }
22778 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22779 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22780 if (!SWIG_IsOK(ecode2)) {
22781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22782 }
22783 arg2 = static_cast< bool >(val2);
22784 if (arg1) (arg1)->m_controlDown = arg2;
22785
22786 resultobj = SWIG_Py_Void();
22787 return resultobj;
22788 fail:
22789 return NULL;
22790 }
22791
22792
22793 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22794 PyObject *resultobj = 0;
22795 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22796 bool result;
22797 void *argp1 = 0 ;
22798 int res1 = 0 ;
22799 PyObject *swig_obj[1] ;
22800
22801 if (!args) SWIG_fail;
22802 swig_obj[0] = args;
22803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22804 if (!SWIG_IsOK(res1)) {
22805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22806 }
22807 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22808 result = (bool) ((arg1)->m_controlDown);
22809 {
22810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22811 }
22812 return resultobj;
22813 fail:
22814 return NULL;
22815 }
22816
22817
22818 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22819 PyObject *resultobj = 0;
22820 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22821 bool arg2 ;
22822 void *argp1 = 0 ;
22823 int res1 = 0 ;
22824 bool val2 ;
22825 int ecode2 = 0 ;
22826 PyObject *swig_obj[2] ;
22827
22828 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22830 if (!SWIG_IsOK(res1)) {
22831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22832 }
22833 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22834 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22835 if (!SWIG_IsOK(ecode2)) {
22836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22837 }
22838 arg2 = static_cast< bool >(val2);
22839 if (arg1) (arg1)->m_shiftDown = arg2;
22840
22841 resultobj = SWIG_Py_Void();
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22849 PyObject *resultobj = 0;
22850 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22851 bool result;
22852 void *argp1 = 0 ;
22853 int res1 = 0 ;
22854 PyObject *swig_obj[1] ;
22855
22856 if (!args) SWIG_fail;
22857 swig_obj[0] = args;
22858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22859 if (!SWIG_IsOK(res1)) {
22860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22861 }
22862 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22863 result = (bool) ((arg1)->m_shiftDown);
22864 {
22865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22866 }
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22874 PyObject *resultobj = 0;
22875 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22876 bool arg2 ;
22877 void *argp1 = 0 ;
22878 int res1 = 0 ;
22879 bool val2 ;
22880 int ecode2 = 0 ;
22881 PyObject *swig_obj[2] ;
22882
22883 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22887 }
22888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22889 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22890 if (!SWIG_IsOK(ecode2)) {
22891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22892 }
22893 arg2 = static_cast< bool >(val2);
22894 if (arg1) (arg1)->m_altDown = arg2;
22895
22896 resultobj = SWIG_Py_Void();
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22904 PyObject *resultobj = 0;
22905 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22906 bool result;
22907 void *argp1 = 0 ;
22908 int res1 = 0 ;
22909 PyObject *swig_obj[1] ;
22910
22911 if (!args) SWIG_fail;
22912 swig_obj[0] = args;
22913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22914 if (!SWIG_IsOK(res1)) {
22915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22916 }
22917 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22918 result = (bool) ((arg1)->m_altDown);
22919 {
22920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22921 }
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *resultobj = 0;
22930 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22931 bool arg2 ;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 bool val2 ;
22935 int ecode2 = 0 ;
22936 PyObject *swig_obj[2] ;
22937
22938 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22942 }
22943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22944 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22945 if (!SWIG_IsOK(ecode2)) {
22946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22947 }
22948 arg2 = static_cast< bool >(val2);
22949 if (arg1) (arg1)->m_metaDown = arg2;
22950
22951 resultobj = SWIG_Py_Void();
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 PyObject *resultobj = 0;
22960 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22961 bool result;
22962 void *argp1 = 0 ;
22963 int res1 = 0 ;
22964 PyObject *swig_obj[1] ;
22965
22966 if (!args) SWIG_fail;
22967 swig_obj[0] = args;
22968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22971 }
22972 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22973 result = (bool) ((arg1)->m_metaDown);
22974 {
22975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22976 }
22977 return resultobj;
22978 fail:
22979 return NULL;
22980 }
22981
22982
22983 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 PyObject *resultobj = 0;
22985 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22986 bool arg2 ;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 bool val2 ;
22990 int ecode2 = 0 ;
22991 PyObject *swig_obj[2] ;
22992
22993 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22997 }
22998 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22999 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23000 if (!SWIG_IsOK(ecode2)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23002 }
23003 arg2 = static_cast< bool >(val2);
23004 if (arg1) (arg1)->m_scanCode = arg2;
23005
23006 resultobj = SWIG_Py_Void();
23007 return resultobj;
23008 fail:
23009 return NULL;
23010 }
23011
23012
23013 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23014 PyObject *resultobj = 0;
23015 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23016 bool result;
23017 void *argp1 = 0 ;
23018 int res1 = 0 ;
23019 PyObject *swig_obj[1] ;
23020
23021 if (!args) SWIG_fail;
23022 swig_obj[0] = args;
23023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23024 if (!SWIG_IsOK(res1)) {
23025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23026 }
23027 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23028 result = (bool) ((arg1)->m_scanCode);
23029 {
23030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23031 }
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23039 PyObject *resultobj = 0;
23040 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23041 unsigned int arg2 ;
23042 void *argp1 = 0 ;
23043 int res1 = 0 ;
23044 unsigned int val2 ;
23045 int ecode2 = 0 ;
23046 PyObject *swig_obj[2] ;
23047
23048 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23052 }
23053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23054 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23055 if (!SWIG_IsOK(ecode2)) {
23056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23057 }
23058 arg2 = static_cast< unsigned int >(val2);
23059 if (arg1) (arg1)->m_rawCode = arg2;
23060
23061 resultobj = SWIG_Py_Void();
23062 return resultobj;
23063 fail:
23064 return NULL;
23065 }
23066
23067
23068 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23069 PyObject *resultobj = 0;
23070 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23071 unsigned int result;
23072 void *argp1 = 0 ;
23073 int res1 = 0 ;
23074 PyObject *swig_obj[1] ;
23075
23076 if (!args) SWIG_fail;
23077 swig_obj[0] = args;
23078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23079 if (!SWIG_IsOK(res1)) {
23080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23081 }
23082 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23083 result = (unsigned int) ((arg1)->m_rawCode);
23084 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23092 PyObject *resultobj = 0;
23093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23094 unsigned int arg2 ;
23095 void *argp1 = 0 ;
23096 int res1 = 0 ;
23097 unsigned int val2 ;
23098 int ecode2 = 0 ;
23099 PyObject *swig_obj[2] ;
23100
23101 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23103 if (!SWIG_IsOK(res1)) {
23104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23105 }
23106 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23107 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23108 if (!SWIG_IsOK(ecode2)) {
23109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23110 }
23111 arg2 = static_cast< unsigned int >(val2);
23112 if (arg1) (arg1)->m_rawFlags = arg2;
23113
23114 resultobj = SWIG_Py_Void();
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23122 PyObject *resultobj = 0;
23123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23124 unsigned int result;
23125 void *argp1 = 0 ;
23126 int res1 = 0 ;
23127 PyObject *swig_obj[1] ;
23128
23129 if (!args) SWIG_fail;
23130 swig_obj[0] = args;
23131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23132 if (!SWIG_IsOK(res1)) {
23133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23134 }
23135 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23136 result = (unsigned int) ((arg1)->m_rawFlags);
23137 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23145 PyObject *obj;
23146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23147 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23148 return SWIG_Py_Void();
23149 }
23150
23151 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23152 return SWIG_Python_InitShadowInstance(args);
23153 }
23154
23155 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23156 PyObject *resultobj = 0;
23157 wxSize const &arg1_defvalue = wxDefaultSize ;
23158 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23159 int arg2 = (int) 0 ;
23160 wxSizeEvent *result = 0 ;
23161 wxSize temp1 ;
23162 int val2 ;
23163 int ecode2 = 0 ;
23164 PyObject * obj0 = 0 ;
23165 PyObject * obj1 = 0 ;
23166 char * kwnames[] = {
23167 (char *) "sz",(char *) "winid", NULL
23168 };
23169
23170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23171 if (obj0) {
23172 {
23173 arg1 = &temp1;
23174 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23175 }
23176 }
23177 if (obj1) {
23178 ecode2 = SWIG_AsVal_int(obj1, &val2);
23179 if (!SWIG_IsOK(ecode2)) {
23180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23181 }
23182 arg2 = static_cast< int >(val2);
23183 }
23184 {
23185 PyThreadState* __tstate = wxPyBeginAllowThreads();
23186 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23187 wxPyEndAllowThreads(__tstate);
23188 if (PyErr_Occurred()) SWIG_fail;
23189 }
23190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23198 PyObject *resultobj = 0;
23199 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23200 wxSize result;
23201 void *argp1 = 0 ;
23202 int res1 = 0 ;
23203 PyObject *swig_obj[1] ;
23204
23205 if (!args) SWIG_fail;
23206 swig_obj[0] = args;
23207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23208 if (!SWIG_IsOK(res1)) {
23209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23210 }
23211 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = ((wxSizeEvent const *)arg1)->GetSize();
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23226 PyObject *resultobj = 0;
23227 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23228 wxRect result;
23229 void *argp1 = 0 ;
23230 int res1 = 0 ;
23231 PyObject *swig_obj[1] ;
23232
23233 if (!args) SWIG_fail;
23234 swig_obj[0] = args;
23235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23236 if (!SWIG_IsOK(res1)) {
23237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23238 }
23239 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = ((wxSizeEvent const *)arg1)->GetRect();
23243 wxPyEndAllowThreads(__tstate);
23244 if (PyErr_Occurred()) SWIG_fail;
23245 }
23246 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23247 return resultobj;
23248 fail:
23249 return NULL;
23250 }
23251
23252
23253 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23254 PyObject *resultobj = 0;
23255 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23256 wxRect arg2 ;
23257 void *argp1 = 0 ;
23258 int res1 = 0 ;
23259 void *argp2 ;
23260 int res2 = 0 ;
23261 PyObject * obj0 = 0 ;
23262 PyObject * obj1 = 0 ;
23263 char * kwnames[] = {
23264 (char *) "self",(char *) "rect", NULL
23265 };
23266
23267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23269 if (!SWIG_IsOK(res1)) {
23270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23271 }
23272 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23273 {
23274 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23275 if (!SWIG_IsOK(res2)) {
23276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23277 }
23278 if (!argp2) {
23279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23280 } else {
23281 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23282 arg2 = *temp;
23283 if (SWIG_IsNewObj(res2)) delete temp;
23284 }
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 (arg1)->SetRect(arg2);
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 resultobj = SWIG_Py_Void();
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj = 0;
23301 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23302 wxSize arg2 ;
23303 void *argp1 = 0 ;
23304 int res1 = 0 ;
23305 void *argp2 ;
23306 int res2 = 0 ;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char * kwnames[] = {
23310 (char *) "self",(char *) "size", NULL
23311 };
23312
23313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23315 if (!SWIG_IsOK(res1)) {
23316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23317 }
23318 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23319 {
23320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23321 if (!SWIG_IsOK(res2)) {
23322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23323 }
23324 if (!argp2) {
23325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23326 } else {
23327 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23328 arg2 = *temp;
23329 if (SWIG_IsNewObj(res2)) delete temp;
23330 }
23331 }
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 wxSizeEvent_SetSize(arg1,arg2);
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 resultobj = SWIG_Py_Void();
23339 return resultobj;
23340 fail:
23341 return NULL;
23342 }
23343
23344
23345 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23346 PyObject *resultobj = 0;
23347 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23348 wxSize *arg2 = (wxSize *) 0 ;
23349 void *argp1 = 0 ;
23350 int res1 = 0 ;
23351 void *argp2 = 0 ;
23352 int res2 = 0 ;
23353 PyObject *swig_obj[2] ;
23354
23355 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23357 if (!SWIG_IsOK(res1)) {
23358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23359 }
23360 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23361 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23362 if (!SWIG_IsOK(res2)) {
23363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23364 }
23365 arg2 = reinterpret_cast< wxSize * >(argp2);
23366 if (arg1) (arg1)->m_size = *arg2;
23367
23368 resultobj = SWIG_Py_Void();
23369 return resultobj;
23370 fail:
23371 return NULL;
23372 }
23373
23374
23375 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23376 PyObject *resultobj = 0;
23377 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23378 wxSize *result = 0 ;
23379 void *argp1 = 0 ;
23380 int res1 = 0 ;
23381 PyObject *swig_obj[1] ;
23382
23383 if (!args) SWIG_fail;
23384 swig_obj[0] = args;
23385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23386 if (!SWIG_IsOK(res1)) {
23387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23388 }
23389 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23390 result = (wxSize *)& ((arg1)->m_size);
23391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23399 PyObject *resultobj = 0;
23400 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23401 wxRect *arg2 = (wxRect *) 0 ;
23402 void *argp1 = 0 ;
23403 int res1 = 0 ;
23404 void *argp2 = 0 ;
23405 int res2 = 0 ;
23406 PyObject *swig_obj[2] ;
23407
23408 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23410 if (!SWIG_IsOK(res1)) {
23411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23412 }
23413 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23414 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23415 if (!SWIG_IsOK(res2)) {
23416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23417 }
23418 arg2 = reinterpret_cast< wxRect * >(argp2);
23419 if (arg1) (arg1)->m_rect = *arg2;
23420
23421 resultobj = SWIG_Py_Void();
23422 return resultobj;
23423 fail:
23424 return NULL;
23425 }
23426
23427
23428 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23429 PyObject *resultobj = 0;
23430 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23431 wxRect *result = 0 ;
23432 void *argp1 = 0 ;
23433 int res1 = 0 ;
23434 PyObject *swig_obj[1] ;
23435
23436 if (!args) SWIG_fail;
23437 swig_obj[0] = args;
23438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23439 if (!SWIG_IsOK(res1)) {
23440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23441 }
23442 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23443 result = (wxRect *)& ((arg1)->m_rect);
23444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23452 PyObject *obj;
23453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23454 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23455 return SWIG_Py_Void();
23456 }
23457
23458 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459 return SWIG_Python_InitShadowInstance(args);
23460 }
23461
23462 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = 0;
23464 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23465 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23466 int arg2 = (int) 0 ;
23467 wxMoveEvent *result = 0 ;
23468 wxPoint temp1 ;
23469 int val2 ;
23470 int ecode2 = 0 ;
23471 PyObject * obj0 = 0 ;
23472 PyObject * obj1 = 0 ;
23473 char * kwnames[] = {
23474 (char *) "pos",(char *) "winid", NULL
23475 };
23476
23477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23478 if (obj0) {
23479 {
23480 arg1 = &temp1;
23481 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23482 }
23483 }
23484 if (obj1) {
23485 ecode2 = SWIG_AsVal_int(obj1, &val2);
23486 if (!SWIG_IsOK(ecode2)) {
23487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23488 }
23489 arg2 = static_cast< int >(val2);
23490 }
23491 {
23492 PyThreadState* __tstate = wxPyBeginAllowThreads();
23493 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23494 wxPyEndAllowThreads(__tstate);
23495 if (PyErr_Occurred()) SWIG_fail;
23496 }
23497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23498 return resultobj;
23499 fail:
23500 return NULL;
23501 }
23502
23503
23504 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23505 PyObject *resultobj = 0;
23506 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23507 wxPoint result;
23508 void *argp1 = 0 ;
23509 int res1 = 0 ;
23510 PyObject *swig_obj[1] ;
23511
23512 if (!args) SWIG_fail;
23513 swig_obj[0] = args;
23514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23515 if (!SWIG_IsOK(res1)) {
23516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23517 }
23518 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 result = ((wxMoveEvent const *)arg1)->GetPosition();
23522 wxPyEndAllowThreads(__tstate);
23523 if (PyErr_Occurred()) SWIG_fail;
23524 }
23525 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23533 PyObject *resultobj = 0;
23534 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23535 wxRect result;
23536 void *argp1 = 0 ;
23537 int res1 = 0 ;
23538 PyObject *swig_obj[1] ;
23539
23540 if (!args) SWIG_fail;
23541 swig_obj[0] = args;
23542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23543 if (!SWIG_IsOK(res1)) {
23544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23545 }
23546 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = ((wxMoveEvent const *)arg1)->GetRect();
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23561 PyObject *resultobj = 0;
23562 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23563 wxRect *arg2 = 0 ;
23564 void *argp1 = 0 ;
23565 int res1 = 0 ;
23566 wxRect temp2 ;
23567 PyObject * obj0 = 0 ;
23568 PyObject * obj1 = 0 ;
23569 char * kwnames[] = {
23570 (char *) "self",(char *) "rect", NULL
23571 };
23572
23573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23575 if (!SWIG_IsOK(res1)) {
23576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23577 }
23578 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23579 {
23580 arg2 = &temp2;
23581 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23582 }
23583 {
23584 PyThreadState* __tstate = wxPyBeginAllowThreads();
23585 (arg1)->SetRect((wxRect const &)*arg2);
23586 wxPyEndAllowThreads(__tstate);
23587 if (PyErr_Occurred()) SWIG_fail;
23588 }
23589 resultobj = SWIG_Py_Void();
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj = 0;
23598 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23599 wxPoint *arg2 = 0 ;
23600 void *argp1 = 0 ;
23601 int res1 = 0 ;
23602 wxPoint temp2 ;
23603 PyObject * obj0 = 0 ;
23604 PyObject * obj1 = 0 ;
23605 char * kwnames[] = {
23606 (char *) "self",(char *) "pos", NULL
23607 };
23608
23609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23611 if (!SWIG_IsOK(res1)) {
23612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23613 }
23614 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23615 {
23616 arg2 = &temp2;
23617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23618 }
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 (arg1)->SetPosition((wxPoint const &)*arg2);
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 resultobj = SWIG_Py_Void();
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23633 PyObject *obj;
23634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23635 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23636 return SWIG_Py_Void();
23637 }
23638
23639 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23640 return SWIG_Python_InitShadowInstance(args);
23641 }
23642
23643 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj = 0;
23645 int arg1 = (int) 0 ;
23646 wxPaintEvent *result = 0 ;
23647 int val1 ;
23648 int ecode1 = 0 ;
23649 PyObject * obj0 = 0 ;
23650 char * kwnames[] = {
23651 (char *) "Id", NULL
23652 };
23653
23654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23655 if (obj0) {
23656 ecode1 = SWIG_AsVal_int(obj0, &val1);
23657 if (!SWIG_IsOK(ecode1)) {
23658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23659 }
23660 arg1 = static_cast< int >(val1);
23661 }
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23676 PyObject *obj;
23677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23678 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23679 return SWIG_Py_Void();
23680 }
23681
23682 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23683 return SWIG_Python_InitShadowInstance(args);
23684 }
23685
23686 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj = 0;
23688 int arg1 = (int) 0 ;
23689 wxNcPaintEvent *result = 0 ;
23690 int val1 ;
23691 int ecode1 = 0 ;
23692 PyObject * obj0 = 0 ;
23693 char * kwnames[] = {
23694 (char *) "winid", NULL
23695 };
23696
23697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23698 if (obj0) {
23699 ecode1 = SWIG_AsVal_int(obj0, &val1);
23700 if (!SWIG_IsOK(ecode1)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23702 }
23703 arg1 = static_cast< int >(val1);
23704 }
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23719 PyObject *obj;
23720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23721 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23722 return SWIG_Py_Void();
23723 }
23724
23725 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23726 return SWIG_Python_InitShadowInstance(args);
23727 }
23728
23729 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj = 0;
23731 int arg1 = (int) 0 ;
23732 wxDC *arg2 = (wxDC *) NULL ;
23733 wxEraseEvent *result = 0 ;
23734 int val1 ;
23735 int ecode1 = 0 ;
23736 void *argp2 = 0 ;
23737 int res2 = 0 ;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "Id",(char *) "dc", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23745 if (obj0) {
23746 ecode1 = SWIG_AsVal_int(obj0, &val1);
23747 if (!SWIG_IsOK(ecode1)) {
23748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23749 }
23750 arg1 = static_cast< int >(val1);
23751 }
23752 if (obj1) {
23753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23754 if (!SWIG_IsOK(res2)) {
23755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23756 }
23757 arg2 = reinterpret_cast< wxDC * >(argp2);
23758 }
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23773 PyObject *resultobj = 0;
23774 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23775 wxDC *result = 0 ;
23776 void *argp1 = 0 ;
23777 int res1 = 0 ;
23778 PyObject *swig_obj[1] ;
23779
23780 if (!args) SWIG_fail;
23781 swig_obj[0] = args;
23782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23783 if (!SWIG_IsOK(res1)) {
23784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23785 }
23786 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 {
23794 resultobj = wxPyMake_wxObject(result, (bool)0);
23795 }
23796 return resultobj;
23797 fail:
23798 return NULL;
23799 }
23800
23801
23802 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23803 PyObject *obj;
23804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23805 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23806 return SWIG_Py_Void();
23807 }
23808
23809 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 return SWIG_Python_InitShadowInstance(args);
23811 }
23812
23813 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj = 0;
23815 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23816 int arg2 = (int) 0 ;
23817 wxFocusEvent *result = 0 ;
23818 int val1 ;
23819 int ecode1 = 0 ;
23820 int val2 ;
23821 int ecode2 = 0 ;
23822 PyObject * obj0 = 0 ;
23823 PyObject * obj1 = 0 ;
23824 char * kwnames[] = {
23825 (char *) "type",(char *) "winid", NULL
23826 };
23827
23828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23829 if (obj0) {
23830 ecode1 = SWIG_AsVal_int(obj0, &val1);
23831 if (!SWIG_IsOK(ecode1)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23833 }
23834 arg1 = static_cast< wxEventType >(val1);
23835 }
23836 if (obj1) {
23837 ecode2 = SWIG_AsVal_int(obj1, &val2);
23838 if (!SWIG_IsOK(ecode2)) {
23839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23840 }
23841 arg2 = static_cast< int >(val2);
23842 }
23843 {
23844 PyThreadState* __tstate = wxPyBeginAllowThreads();
23845 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23857 PyObject *resultobj = 0;
23858 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23859 wxWindow *result = 0 ;
23860 void *argp1 = 0 ;
23861 int res1 = 0 ;
23862 PyObject *swig_obj[1] ;
23863
23864 if (!args) SWIG_fail;
23865 swig_obj[0] = args;
23866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23867 if (!SWIG_IsOK(res1)) {
23868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23869 }
23870 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23871 {
23872 PyThreadState* __tstate = wxPyBeginAllowThreads();
23873 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 {
23878 resultobj = wxPyMake_wxObject(result, (bool)0);
23879 }
23880 return resultobj;
23881 fail:
23882 return NULL;
23883 }
23884
23885
23886 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23887 PyObject *resultobj = 0;
23888 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23889 wxWindow *arg2 = (wxWindow *) 0 ;
23890 void *argp1 = 0 ;
23891 int res1 = 0 ;
23892 void *argp2 = 0 ;
23893 int res2 = 0 ;
23894 PyObject * obj0 = 0 ;
23895 PyObject * obj1 = 0 ;
23896 char * kwnames[] = {
23897 (char *) "self",(char *) "win", NULL
23898 };
23899
23900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23902 if (!SWIG_IsOK(res1)) {
23903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23904 }
23905 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23907 if (!SWIG_IsOK(res2)) {
23908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23909 }
23910 arg2 = reinterpret_cast< wxWindow * >(argp2);
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 (arg1)->SetWindow(arg2);
23914 wxPyEndAllowThreads(__tstate);
23915 if (PyErr_Occurred()) SWIG_fail;
23916 }
23917 resultobj = SWIG_Py_Void();
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23925 PyObject *obj;
23926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23927 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23928 return SWIG_Py_Void();
23929 }
23930
23931 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 return SWIG_Python_InitShadowInstance(args);
23933 }
23934
23935 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj = 0;
23937 wxWindow *arg1 = (wxWindow *) NULL ;
23938 wxChildFocusEvent *result = 0 ;
23939 void *argp1 = 0 ;
23940 int res1 = 0 ;
23941 PyObject * obj0 = 0 ;
23942 char * kwnames[] = {
23943 (char *) "win", NULL
23944 };
23945
23946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23947 if (obj0) {
23948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23949 if (!SWIG_IsOK(res1)) {
23950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23951 }
23952 arg1 = reinterpret_cast< wxWindow * >(argp1);
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23968 PyObject *resultobj = 0;
23969 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23970 wxWindow *result = 0 ;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 PyObject *swig_obj[1] ;
23974
23975 if (!args) SWIG_fail;
23976 swig_obj[0] = args;
23977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23978 if (!SWIG_IsOK(res1)) {
23979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23980 }
23981 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 {
23989 resultobj = wxPyMake_wxObject(result, (bool)0);
23990 }
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23998 PyObject *obj;
23999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24000 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24001 return SWIG_Py_Void();
24002 }
24003
24004 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 return SWIG_Python_InitShadowInstance(args);
24006 }
24007
24008 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24009 PyObject *resultobj = 0;
24010 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24011 bool arg2 = (bool) true ;
24012 int arg3 = (int) 0 ;
24013 wxActivateEvent *result = 0 ;
24014 int val1 ;
24015 int ecode1 = 0 ;
24016 bool val2 ;
24017 int ecode2 = 0 ;
24018 int val3 ;
24019 int ecode3 = 0 ;
24020 PyObject * obj0 = 0 ;
24021 PyObject * obj1 = 0 ;
24022 PyObject * obj2 = 0 ;
24023 char * kwnames[] = {
24024 (char *) "type",(char *) "active",(char *) "Id", NULL
24025 };
24026
24027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24028 if (obj0) {
24029 ecode1 = SWIG_AsVal_int(obj0, &val1);
24030 if (!SWIG_IsOK(ecode1)) {
24031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24032 }
24033 arg1 = static_cast< wxEventType >(val1);
24034 }
24035 if (obj1) {
24036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24037 if (!SWIG_IsOK(ecode2)) {
24038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24039 }
24040 arg2 = static_cast< bool >(val2);
24041 }
24042 if (obj2) {
24043 ecode3 = SWIG_AsVal_int(obj2, &val3);
24044 if (!SWIG_IsOK(ecode3)) {
24045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24046 }
24047 arg3 = static_cast< int >(val3);
24048 }
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24052 wxPyEndAllowThreads(__tstate);
24053 if (PyErr_Occurred()) SWIG_fail;
24054 }
24055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24056 return resultobj;
24057 fail:
24058 return NULL;
24059 }
24060
24061
24062 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24063 PyObject *resultobj = 0;
24064 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24065 bool result;
24066 void *argp1 = 0 ;
24067 int res1 = 0 ;
24068 PyObject *swig_obj[1] ;
24069
24070 if (!args) SWIG_fail;
24071 swig_obj[0] = args;
24072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24073 if (!SWIG_IsOK(res1)) {
24074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24075 }
24076 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24080 wxPyEndAllowThreads(__tstate);
24081 if (PyErr_Occurred()) SWIG_fail;
24082 }
24083 {
24084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24085 }
24086 return resultobj;
24087 fail:
24088 return NULL;
24089 }
24090
24091
24092 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24093 PyObject *obj;
24094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24095 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24096 return SWIG_Py_Void();
24097 }
24098
24099 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 return SWIG_Python_InitShadowInstance(args);
24101 }
24102
24103 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj = 0;
24105 int arg1 = (int) 0 ;
24106 wxInitDialogEvent *result = 0 ;
24107 int val1 ;
24108 int ecode1 = 0 ;
24109 PyObject * obj0 = 0 ;
24110 char * kwnames[] = {
24111 (char *) "Id", NULL
24112 };
24113
24114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24115 if (obj0) {
24116 ecode1 = SWIG_AsVal_int(obj0, &val1);
24117 if (!SWIG_IsOK(ecode1)) {
24118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24119 }
24120 arg1 = static_cast< int >(val1);
24121 }
24122 {
24123 PyThreadState* __tstate = wxPyBeginAllowThreads();
24124 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24125 wxPyEndAllowThreads(__tstate);
24126 if (PyErr_Occurred()) SWIG_fail;
24127 }
24128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24129 return resultobj;
24130 fail:
24131 return NULL;
24132 }
24133
24134
24135 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24136 PyObject *obj;
24137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24138 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24139 return SWIG_Py_Void();
24140 }
24141
24142 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 return SWIG_Python_InitShadowInstance(args);
24144 }
24145
24146 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24147 PyObject *resultobj = 0;
24148 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24149 int arg2 = (int) 0 ;
24150 wxMenu *arg3 = (wxMenu *) NULL ;
24151 wxMenuEvent *result = 0 ;
24152 int val1 ;
24153 int ecode1 = 0 ;
24154 int val2 ;
24155 int ecode2 = 0 ;
24156 void *argp3 = 0 ;
24157 int res3 = 0 ;
24158 PyObject * obj0 = 0 ;
24159 PyObject * obj1 = 0 ;
24160 PyObject * obj2 = 0 ;
24161 char * kwnames[] = {
24162 (char *) "type",(char *) "winid",(char *) "menu", NULL
24163 };
24164
24165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24166 if (obj0) {
24167 ecode1 = SWIG_AsVal_int(obj0, &val1);
24168 if (!SWIG_IsOK(ecode1)) {
24169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24170 }
24171 arg1 = static_cast< wxEventType >(val1);
24172 }
24173 if (obj1) {
24174 ecode2 = SWIG_AsVal_int(obj1, &val2);
24175 if (!SWIG_IsOK(ecode2)) {
24176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24177 }
24178 arg2 = static_cast< int >(val2);
24179 }
24180 if (obj2) {
24181 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24182 if (!SWIG_IsOK(res3)) {
24183 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24184 }
24185 arg3 = reinterpret_cast< wxMenu * >(argp3);
24186 }
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *resultobj = 0;
24202 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24203 int result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 PyObject *swig_obj[1] ;
24207
24208 if (!args) SWIG_fail;
24209 swig_obj[0] = args;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24215 {
24216 PyThreadState* __tstate = wxPyBeginAllowThreads();
24217 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 resultobj = SWIG_From_int(static_cast< int >(result));
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24229 PyObject *resultobj = 0;
24230 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24231 bool result;
24232 void *argp1 = 0 ;
24233 int res1 = 0 ;
24234 PyObject *swig_obj[1] ;
24235
24236 if (!args) SWIG_fail;
24237 swig_obj[0] = args;
24238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24239 if (!SWIG_IsOK(res1)) {
24240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24241 }
24242 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 {
24250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24251 }
24252 return resultobj;
24253 fail:
24254 return NULL;
24255 }
24256
24257
24258 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24259 PyObject *resultobj = 0;
24260 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24261 wxMenu *result = 0 ;
24262 void *argp1 = 0 ;
24263 int res1 = 0 ;
24264 PyObject *swig_obj[1] ;
24265
24266 if (!args) SWIG_fail;
24267 swig_obj[0] = args;
24268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24269 if (!SWIG_IsOK(res1)) {
24270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24271 }
24272 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24273 {
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24276 wxPyEndAllowThreads(__tstate);
24277 if (PyErr_Occurred()) SWIG_fail;
24278 }
24279 {
24280 resultobj = wxPyMake_wxObject(result, (bool)0);
24281 }
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24289 PyObject *obj;
24290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24291 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24292 return SWIG_Py_Void();
24293 }
24294
24295 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24296 return SWIG_Python_InitShadowInstance(args);
24297 }
24298
24299 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24300 PyObject *resultobj = 0;
24301 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24302 int arg2 = (int) 0 ;
24303 wxCloseEvent *result = 0 ;
24304 int val1 ;
24305 int ecode1 = 0 ;
24306 int val2 ;
24307 int ecode2 = 0 ;
24308 PyObject * obj0 = 0 ;
24309 PyObject * obj1 = 0 ;
24310 char * kwnames[] = {
24311 (char *) "type",(char *) "winid", NULL
24312 };
24313
24314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24315 if (obj0) {
24316 ecode1 = SWIG_AsVal_int(obj0, &val1);
24317 if (!SWIG_IsOK(ecode1)) {
24318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24319 }
24320 arg1 = static_cast< wxEventType >(val1);
24321 }
24322 if (obj1) {
24323 ecode2 = SWIG_AsVal_int(obj1, &val2);
24324 if (!SWIG_IsOK(ecode2)) {
24325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24326 }
24327 arg2 = static_cast< int >(val2);
24328 }
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24343 PyObject *resultobj = 0;
24344 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24345 bool arg2 ;
24346 void *argp1 = 0 ;
24347 int res1 = 0 ;
24348 bool val2 ;
24349 int ecode2 = 0 ;
24350 PyObject * obj0 = 0 ;
24351 PyObject * obj1 = 0 ;
24352 char * kwnames[] = {
24353 (char *) "self",(char *) "logOff", NULL
24354 };
24355
24356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24358 if (!SWIG_IsOK(res1)) {
24359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24360 }
24361 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24363 if (!SWIG_IsOK(ecode2)) {
24364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24365 }
24366 arg2 = static_cast< bool >(val2);
24367 {
24368 PyThreadState* __tstate = wxPyBeginAllowThreads();
24369 (arg1)->SetLoggingOff(arg2);
24370 wxPyEndAllowThreads(__tstate);
24371 if (PyErr_Occurred()) SWIG_fail;
24372 }
24373 resultobj = SWIG_Py_Void();
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24381 PyObject *resultobj = 0;
24382 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24383 bool result;
24384 void *argp1 = 0 ;
24385 int res1 = 0 ;
24386 PyObject *swig_obj[1] ;
24387
24388 if (!args) SWIG_fail;
24389 swig_obj[0] = args;
24390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24391 if (!SWIG_IsOK(res1)) {
24392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24393 }
24394 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 {
24402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24403 }
24404 return resultobj;
24405 fail:
24406 return NULL;
24407 }
24408
24409
24410 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24411 PyObject *resultobj = 0;
24412 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24413 bool arg2 = (bool) true ;
24414 void *argp1 = 0 ;
24415 int res1 = 0 ;
24416 bool val2 ;
24417 int ecode2 = 0 ;
24418 PyObject * obj0 = 0 ;
24419 PyObject * obj1 = 0 ;
24420 char * kwnames[] = {
24421 (char *) "self",(char *) "veto", NULL
24422 };
24423
24424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24426 if (!SWIG_IsOK(res1)) {
24427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24428 }
24429 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24430 if (obj1) {
24431 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24432 if (!SWIG_IsOK(ecode2)) {
24433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24434 }
24435 arg2 = static_cast< bool >(val2);
24436 }
24437 {
24438 PyThreadState* __tstate = wxPyBeginAllowThreads();
24439 (arg1)->Veto(arg2);
24440 wxPyEndAllowThreads(__tstate);
24441 if (PyErr_Occurred()) SWIG_fail;
24442 }
24443 resultobj = SWIG_Py_Void();
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24451 PyObject *resultobj = 0;
24452 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24453 bool result;
24454 void *argp1 = 0 ;
24455 int res1 = 0 ;
24456 PyObject *swig_obj[1] ;
24457
24458 if (!args) SWIG_fail;
24459 swig_obj[0] = args;
24460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24461 if (!SWIG_IsOK(res1)) {
24462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24463 }
24464 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24465 {
24466 PyThreadState* __tstate = wxPyBeginAllowThreads();
24467 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24468 wxPyEndAllowThreads(__tstate);
24469 if (PyErr_Occurred()) SWIG_fail;
24470 }
24471 {
24472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24473 }
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj = 0;
24482 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24483 bool arg2 ;
24484 void *argp1 = 0 ;
24485 int res1 = 0 ;
24486 bool val2 ;
24487 int ecode2 = 0 ;
24488 PyObject * obj0 = 0 ;
24489 PyObject * obj1 = 0 ;
24490 char * kwnames[] = {
24491 (char *) "self",(char *) "canVeto", NULL
24492 };
24493
24494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24496 if (!SWIG_IsOK(res1)) {
24497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24498 }
24499 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24501 if (!SWIG_IsOK(ecode2)) {
24502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24503 }
24504 arg2 = static_cast< bool >(val2);
24505 {
24506 PyThreadState* __tstate = wxPyBeginAllowThreads();
24507 (arg1)->SetCanVeto(arg2);
24508 wxPyEndAllowThreads(__tstate);
24509 if (PyErr_Occurred()) SWIG_fail;
24510 }
24511 resultobj = SWIG_Py_Void();
24512 return resultobj;
24513 fail:
24514 return NULL;
24515 }
24516
24517
24518 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24519 PyObject *resultobj = 0;
24520 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24521 bool result;
24522 void *argp1 = 0 ;
24523 int res1 = 0 ;
24524 PyObject *swig_obj[1] ;
24525
24526 if (!args) SWIG_fail;
24527 swig_obj[0] = args;
24528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24529 if (!SWIG_IsOK(res1)) {
24530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24531 }
24532 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24533 {
24534 PyThreadState* __tstate = wxPyBeginAllowThreads();
24535 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24536 wxPyEndAllowThreads(__tstate);
24537 if (PyErr_Occurred()) SWIG_fail;
24538 }
24539 {
24540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24541 }
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24549 PyObject *obj;
24550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24551 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24552 return SWIG_Py_Void();
24553 }
24554
24555 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 return SWIG_Python_InitShadowInstance(args);
24557 }
24558
24559 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24560 PyObject *resultobj = 0;
24561 int arg1 = (int) 0 ;
24562 bool arg2 = (bool) false ;
24563 wxShowEvent *result = 0 ;
24564 int val1 ;
24565 int ecode1 = 0 ;
24566 bool val2 ;
24567 int ecode2 = 0 ;
24568 PyObject * obj0 = 0 ;
24569 PyObject * obj1 = 0 ;
24570 char * kwnames[] = {
24571 (char *) "winid",(char *) "show", NULL
24572 };
24573
24574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24575 if (obj0) {
24576 ecode1 = SWIG_AsVal_int(obj0, &val1);
24577 if (!SWIG_IsOK(ecode1)) {
24578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24579 }
24580 arg1 = static_cast< int >(val1);
24581 }
24582 if (obj1) {
24583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24584 if (!SWIG_IsOK(ecode2)) {
24585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24586 }
24587 arg2 = static_cast< bool >(val2);
24588 }
24589 {
24590 PyThreadState* __tstate = wxPyBeginAllowThreads();
24591 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj = 0;
24604 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24605 bool arg2 ;
24606 void *argp1 = 0 ;
24607 int res1 = 0 ;
24608 bool val2 ;
24609 int ecode2 = 0 ;
24610 PyObject * obj0 = 0 ;
24611 PyObject * obj1 = 0 ;
24612 char * kwnames[] = {
24613 (char *) "self",(char *) "show", NULL
24614 };
24615
24616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24618 if (!SWIG_IsOK(res1)) {
24619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24620 }
24621 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24622 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24623 if (!SWIG_IsOK(ecode2)) {
24624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24625 }
24626 arg2 = static_cast< bool >(val2);
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 (arg1)->SetShow(arg2);
24630 wxPyEndAllowThreads(__tstate);
24631 if (PyErr_Occurred()) SWIG_fail;
24632 }
24633 resultobj = SWIG_Py_Void();
24634 return resultobj;
24635 fail:
24636 return NULL;
24637 }
24638
24639
24640 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24641 PyObject *resultobj = 0;
24642 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24643 bool result;
24644 void *argp1 = 0 ;
24645 int res1 = 0 ;
24646 PyObject *swig_obj[1] ;
24647
24648 if (!args) SWIG_fail;
24649 swig_obj[0] = args;
24650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24651 if (!SWIG_IsOK(res1)) {
24652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24653 }
24654 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 {
24662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24663 }
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24671 PyObject *obj;
24672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24673 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24674 return SWIG_Py_Void();
24675 }
24676
24677 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24678 return SWIG_Python_InitShadowInstance(args);
24679 }
24680
24681 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj = 0;
24683 int arg1 = (int) 0 ;
24684 bool arg2 = (bool) true ;
24685 wxIconizeEvent *result = 0 ;
24686 int val1 ;
24687 int ecode1 = 0 ;
24688 bool val2 ;
24689 int ecode2 = 0 ;
24690 PyObject * obj0 = 0 ;
24691 PyObject * obj1 = 0 ;
24692 char * kwnames[] = {
24693 (char *) "id",(char *) "iconized", NULL
24694 };
24695
24696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24697 if (obj0) {
24698 ecode1 = SWIG_AsVal_int(obj0, &val1);
24699 if (!SWIG_IsOK(ecode1)) {
24700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24701 }
24702 arg1 = static_cast< int >(val1);
24703 }
24704 if (obj1) {
24705 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24706 if (!SWIG_IsOK(ecode2)) {
24707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24708 }
24709 arg2 = static_cast< bool >(val2);
24710 }
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24727 bool result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24737 }
24738 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)(arg1)->Iconized();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *obj;
24756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24757 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24758 return SWIG_Py_Void();
24759 }
24760
24761 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24762 return SWIG_Python_InitShadowInstance(args);
24763 }
24764
24765 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24766 PyObject *resultobj = 0;
24767 int arg1 = (int) 0 ;
24768 wxMaximizeEvent *result = 0 ;
24769 int val1 ;
24770 int ecode1 = 0 ;
24771 PyObject * obj0 = 0 ;
24772 char * kwnames[] = {
24773 (char *) "id", NULL
24774 };
24775
24776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24777 if (obj0) {
24778 ecode1 = SWIG_AsVal_int(obj0, &val1);
24779 if (!SWIG_IsOK(ecode1)) {
24780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24781 }
24782 arg1 = static_cast< int >(val1);
24783 }
24784 {
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24798 PyObject *obj;
24799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24800 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24801 return SWIG_Py_Void();
24802 }
24803
24804 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24805 return SWIG_Python_InitShadowInstance(args);
24806 }
24807
24808 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24809 PyObject *resultobj = 0;
24810 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24811 wxPoint result;
24812 void *argp1 = 0 ;
24813 int res1 = 0 ;
24814 PyObject *swig_obj[1] ;
24815
24816 if (!args) SWIG_fail;
24817 swig_obj[0] = args;
24818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24819 if (!SWIG_IsOK(res1)) {
24820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24821 }
24822 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (arg1)->GetPosition();
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24837 PyObject *resultobj = 0;
24838 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24839 int result;
24840 void *argp1 = 0 ;
24841 int res1 = 0 ;
24842 PyObject *swig_obj[1] ;
24843
24844 if (!args) SWIG_fail;
24845 swig_obj[0] = args;
24846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24847 if (!SWIG_IsOK(res1)) {
24848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24849 }
24850 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (int)(arg1)->GetNumberOfFiles();
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_From_int(static_cast< int >(result));
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24865 PyObject *resultobj = 0;
24866 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24867 PyObject *result = 0 ;
24868 void *argp1 = 0 ;
24869 int res1 = 0 ;
24870 PyObject *swig_obj[1] ;
24871
24872 if (!args) SWIG_fail;
24873 swig_obj[0] = args;
24874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24875 if (!SWIG_IsOK(res1)) {
24876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24877 }
24878 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = result;
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 PyObject *obj;
24894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24895 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24896 return SWIG_Py_Void();
24897 }
24898
24899 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24900 PyObject *resultobj = 0;
24901 int arg1 = (int) 0 ;
24902 wxUpdateUIEvent *result = 0 ;
24903 int val1 ;
24904 int ecode1 = 0 ;
24905 PyObject * obj0 = 0 ;
24906 char * kwnames[] = {
24907 (char *) "commandId", NULL
24908 };
24909
24910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24911 if (obj0) {
24912 ecode1 = SWIG_AsVal_int(obj0, &val1);
24913 if (!SWIG_IsOK(ecode1)) {
24914 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24915 }
24916 arg1 = static_cast< int >(val1);
24917 }
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24925 return resultobj;
24926 fail:
24927 return NULL;
24928 }
24929
24930
24931 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24932 PyObject *resultobj = 0;
24933 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24934 bool result;
24935 void *argp1 = 0 ;
24936 int res1 = 0 ;
24937 PyObject *swig_obj[1] ;
24938
24939 if (!args) SWIG_fail;
24940 swig_obj[0] = args;
24941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24942 if (!SWIG_IsOK(res1)) {
24943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24944 }
24945 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24949 wxPyEndAllowThreads(__tstate);
24950 if (PyErr_Occurred()) SWIG_fail;
24951 }
24952 {
24953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24954 }
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24962 PyObject *resultobj = 0;
24963 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24964 bool result;
24965 void *argp1 = 0 ;
24966 int res1 = 0 ;
24967 PyObject *swig_obj[1] ;
24968
24969 if (!args) SWIG_fail;
24970 swig_obj[0] = args;
24971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24972 if (!SWIG_IsOK(res1)) {
24973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24974 }
24975 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 {
24983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24984 }
24985 return resultobj;
24986 fail:
24987 return NULL;
24988 }
24989
24990
24991 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24992 PyObject *resultobj = 0;
24993 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24994 bool result;
24995 void *argp1 = 0 ;
24996 int res1 = 0 ;
24997 PyObject *swig_obj[1] ;
24998
24999 if (!args) SWIG_fail;
25000 swig_obj[0] = args;
25001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25002 if (!SWIG_IsOK(res1)) {
25003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25004 }
25005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25006 {
25007 PyThreadState* __tstate = wxPyBeginAllowThreads();
25008 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25009 wxPyEndAllowThreads(__tstate);
25010 if (PyErr_Occurred()) SWIG_fail;
25011 }
25012 {
25013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25014 }
25015 return resultobj;
25016 fail:
25017 return NULL;
25018 }
25019
25020
25021 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25022 PyObject *resultobj = 0;
25023 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25024 wxString result;
25025 void *argp1 = 0 ;
25026 int res1 = 0 ;
25027 PyObject *swig_obj[1] ;
25028
25029 if (!args) SWIG_fail;
25030 swig_obj[0] = args;
25031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25032 if (!SWIG_IsOK(res1)) {
25033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25034 }
25035 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 {
25043 #if wxUSE_UNICODE
25044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25045 #else
25046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25047 #endif
25048 }
25049 return resultobj;
25050 fail:
25051 return NULL;
25052 }
25053
25054
25055 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25056 PyObject *resultobj = 0;
25057 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25058 bool result;
25059 void *argp1 = 0 ;
25060 int res1 = 0 ;
25061 PyObject *swig_obj[1] ;
25062
25063 if (!args) SWIG_fail;
25064 swig_obj[0] = args;
25065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25066 if (!SWIG_IsOK(res1)) {
25067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25068 }
25069 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 {
25077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25078 }
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25086 PyObject *resultobj = 0;
25087 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25088 bool result;
25089 void *argp1 = 0 ;
25090 int res1 = 0 ;
25091 PyObject *swig_obj[1] ;
25092
25093 if (!args) SWIG_fail;
25094 swig_obj[0] = args;
25095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25096 if (!SWIG_IsOK(res1)) {
25097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25098 }
25099 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25103 wxPyEndAllowThreads(__tstate);
25104 if (PyErr_Occurred()) SWIG_fail;
25105 }
25106 {
25107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25108 }
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25116 PyObject *resultobj = 0;
25117 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25118 bool result;
25119 void *argp1 = 0 ;
25120 int res1 = 0 ;
25121 PyObject *swig_obj[1] ;
25122
25123 if (!args) SWIG_fail;
25124 swig_obj[0] = args;
25125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25126 if (!SWIG_IsOK(res1)) {
25127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25128 }
25129 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25133 wxPyEndAllowThreads(__tstate);
25134 if (PyErr_Occurred()) SWIG_fail;
25135 }
25136 {
25137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25138 }
25139 return resultobj;
25140 fail:
25141 return NULL;
25142 }
25143
25144
25145 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25146 PyObject *resultobj = 0;
25147 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25148 bool result;
25149 void *argp1 = 0 ;
25150 int res1 = 0 ;
25151 PyObject *swig_obj[1] ;
25152
25153 if (!args) SWIG_fail;
25154 swig_obj[0] = args;
25155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25156 if (!SWIG_IsOK(res1)) {
25157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25158 }
25159 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25163 wxPyEndAllowThreads(__tstate);
25164 if (PyErr_Occurred()) SWIG_fail;
25165 }
25166 {
25167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25168 }
25169 return resultobj;
25170 fail:
25171 return NULL;
25172 }
25173
25174
25175 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25176 PyObject *resultobj = 0;
25177 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25178 bool arg2 ;
25179 void *argp1 = 0 ;
25180 int res1 = 0 ;
25181 bool val2 ;
25182 int ecode2 = 0 ;
25183 PyObject * obj0 = 0 ;
25184 PyObject * obj1 = 0 ;
25185 char * kwnames[] = {
25186 (char *) "self",(char *) "check", NULL
25187 };
25188
25189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25191 if (!SWIG_IsOK(res1)) {
25192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25193 }
25194 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25196 if (!SWIG_IsOK(ecode2)) {
25197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25198 }
25199 arg2 = static_cast< bool >(val2);
25200 {
25201 PyThreadState* __tstate = wxPyBeginAllowThreads();
25202 (arg1)->Check(arg2);
25203 wxPyEndAllowThreads(__tstate);
25204 if (PyErr_Occurred()) SWIG_fail;
25205 }
25206 resultobj = SWIG_Py_Void();
25207 return resultobj;
25208 fail:
25209 return NULL;
25210 }
25211
25212
25213 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25214 PyObject *resultobj = 0;
25215 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25216 bool arg2 ;
25217 void *argp1 = 0 ;
25218 int res1 = 0 ;
25219 bool val2 ;
25220 int ecode2 = 0 ;
25221 PyObject * obj0 = 0 ;
25222 PyObject * obj1 = 0 ;
25223 char * kwnames[] = {
25224 (char *) "self",(char *) "enable", NULL
25225 };
25226
25227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25229 if (!SWIG_IsOK(res1)) {
25230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25231 }
25232 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25234 if (!SWIG_IsOK(ecode2)) {
25235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25236 }
25237 arg2 = static_cast< bool >(val2);
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 (arg1)->Enable(arg2);
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 resultobj = SWIG_Py_Void();
25245 return resultobj;
25246 fail:
25247 return NULL;
25248 }
25249
25250
25251 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25254 bool arg2 ;
25255 void *argp1 = 0 ;
25256 int res1 = 0 ;
25257 bool val2 ;
25258 int ecode2 = 0 ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "self",(char *) "show", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25267 if (!SWIG_IsOK(res1)) {
25268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25269 }
25270 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25271 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25272 if (!SWIG_IsOK(ecode2)) {
25273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25274 }
25275 arg2 = static_cast< bool >(val2);
25276 {
25277 PyThreadState* __tstate = wxPyBeginAllowThreads();
25278 (arg1)->Show(arg2);
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 resultobj = SWIG_Py_Void();
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj = 0;
25291 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25292 wxString *arg2 = 0 ;
25293 void *argp1 = 0 ;
25294 int res1 = 0 ;
25295 bool temp2 = false ;
25296 PyObject * obj0 = 0 ;
25297 PyObject * obj1 = 0 ;
25298 char * kwnames[] = {
25299 (char *) "self",(char *) "text", NULL
25300 };
25301
25302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25304 if (!SWIG_IsOK(res1)) {
25305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25306 }
25307 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25308 {
25309 arg2 = wxString_in_helper(obj1);
25310 if (arg2 == NULL) SWIG_fail;
25311 temp2 = true;
25312 }
25313 {
25314 PyThreadState* __tstate = wxPyBeginAllowThreads();
25315 (arg1)->SetText((wxString const &)*arg2);
25316 wxPyEndAllowThreads(__tstate);
25317 if (PyErr_Occurred()) SWIG_fail;
25318 }
25319 resultobj = SWIG_Py_Void();
25320 {
25321 if (temp2)
25322 delete arg2;
25323 }
25324 return resultobj;
25325 fail:
25326 {
25327 if (temp2)
25328 delete arg2;
25329 }
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 long arg1 ;
25337 long val1 ;
25338 int ecode1 = 0 ;
25339 PyObject * obj0 = 0 ;
25340 char * kwnames[] = {
25341 (char *) "updateInterval", NULL
25342 };
25343
25344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25345 ecode1 = SWIG_AsVal_long(obj0, &val1);
25346 if (!SWIG_IsOK(ecode1)) {
25347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25348 }
25349 arg1 = static_cast< long >(val1);
25350 {
25351 PyThreadState* __tstate = wxPyBeginAllowThreads();
25352 wxUpdateUIEvent::SetUpdateInterval(arg1);
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 resultobj = SWIG_Py_Void();
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25364 PyObject *resultobj = 0;
25365 long result;
25366
25367 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_From_long(static_cast< long >(result));
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj = 0;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 bool result;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 PyObject * obj0 = 0 ;
25388 char * kwnames[] = {
25389 (char *) "win", NULL
25390 };
25391
25392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25394 if (!SWIG_IsOK(res1)) {
25395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25396 }
25397 arg1 = reinterpret_cast< wxWindow * >(argp1);
25398 {
25399 PyThreadState* __tstate = wxPyBeginAllowThreads();
25400 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25401 wxPyEndAllowThreads(__tstate);
25402 if (PyErr_Occurred()) SWIG_fail;
25403 }
25404 {
25405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25406 }
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25414 PyObject *resultobj = 0;
25415
25416 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 wxUpdateUIEvent::ResetUpdateTime();
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 resultobj = SWIG_Py_Void();
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj = 0;
25432 wxUpdateUIMode arg1 ;
25433 int val1 ;
25434 int ecode1 = 0 ;
25435 PyObject * obj0 = 0 ;
25436 char * kwnames[] = {
25437 (char *) "mode", NULL
25438 };
25439
25440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25441 ecode1 = SWIG_AsVal_int(obj0, &val1);
25442 if (!SWIG_IsOK(ecode1)) {
25443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25444 }
25445 arg1 = static_cast< wxUpdateUIMode >(val1);
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 wxUpdateUIEvent::SetMode(arg1);
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 resultobj = SWIG_Py_Void();
25453 return resultobj;
25454 fail:
25455 return NULL;
25456 }
25457
25458
25459 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25460 PyObject *resultobj = 0;
25461 wxUpdateUIMode result;
25462
25463 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 resultobj = SWIG_From_int(static_cast< int >(result));
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25478 PyObject *obj;
25479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25480 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25481 return SWIG_Py_Void();
25482 }
25483
25484 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25485 return SWIG_Python_InitShadowInstance(args);
25486 }
25487
25488 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25489 PyObject *resultobj = 0;
25490 wxSysColourChangedEvent *result = 0 ;
25491
25492 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25496 wxPyEndAllowThreads(__tstate);
25497 if (PyErr_Occurred()) SWIG_fail;
25498 }
25499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25507 PyObject *obj;
25508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25509 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25510 return SWIG_Py_Void();
25511 }
25512
25513 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 return SWIG_Python_InitShadowInstance(args);
25515 }
25516
25517 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj = 0;
25519 int arg1 = (int) 0 ;
25520 wxWindow *arg2 = (wxWindow *) NULL ;
25521 wxMouseCaptureChangedEvent *result = 0 ;
25522 int val1 ;
25523 int ecode1 = 0 ;
25524 void *argp2 = 0 ;
25525 int res2 = 0 ;
25526 PyObject * obj0 = 0 ;
25527 PyObject * obj1 = 0 ;
25528 char * kwnames[] = {
25529 (char *) "winid",(char *) "gainedCapture", NULL
25530 };
25531
25532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25533 if (obj0) {
25534 ecode1 = SWIG_AsVal_int(obj0, &val1);
25535 if (!SWIG_IsOK(ecode1)) {
25536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25537 }
25538 arg1 = static_cast< int >(val1);
25539 }
25540 if (obj1) {
25541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25542 if (!SWIG_IsOK(res2)) {
25543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25544 }
25545 arg2 = reinterpret_cast< wxWindow * >(argp2);
25546 }
25547 {
25548 PyThreadState* __tstate = wxPyBeginAllowThreads();
25549 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25561 PyObject *resultobj = 0;
25562 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25563 wxWindow *result = 0 ;
25564 void *argp1 = 0 ;
25565 int res1 = 0 ;
25566 PyObject *swig_obj[1] ;
25567
25568 if (!args) SWIG_fail;
25569 swig_obj[0] = args;
25570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25571 if (!SWIG_IsOK(res1)) {
25572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25573 }
25574 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 {
25582 resultobj = wxPyMake_wxObject(result, (bool)0);
25583 }
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25591 PyObject *obj;
25592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25593 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25594 return SWIG_Py_Void();
25595 }
25596
25597 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25598 return SWIG_Python_InitShadowInstance(args);
25599 }
25600
25601 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25602 PyObject *resultobj = 0;
25603 int arg1 = (int) 0 ;
25604 wxMouseCaptureLostEvent *result = 0 ;
25605 int val1 ;
25606 int ecode1 = 0 ;
25607 PyObject * obj0 = 0 ;
25608 char * kwnames[] = {
25609 (char *) "winid", NULL
25610 };
25611
25612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25613 if (obj0) {
25614 ecode1 = SWIG_AsVal_int(obj0, &val1);
25615 if (!SWIG_IsOK(ecode1)) {
25616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25617 }
25618 arg1 = static_cast< int >(val1);
25619 }
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25634 PyObject *obj;
25635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25636 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25637 return SWIG_Py_Void();
25638 }
25639
25640 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25641 return SWIG_Python_InitShadowInstance(args);
25642 }
25643
25644 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25645 PyObject *resultobj = 0;
25646 wxDisplayChangedEvent *result = 0 ;
25647
25648 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25652 wxPyEndAllowThreads(__tstate);
25653 if (PyErr_Occurred()) SWIG_fail;
25654 }
25655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25663 PyObject *obj;
25664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25665 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25666 return SWIG_Py_Void();
25667 }
25668
25669 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 return SWIG_Python_InitShadowInstance(args);
25671 }
25672
25673 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25674 PyObject *resultobj = 0;
25675 int arg1 = (int) 0 ;
25676 wxPaletteChangedEvent *result = 0 ;
25677 int val1 ;
25678 int ecode1 = 0 ;
25679 PyObject * obj0 = 0 ;
25680 char * kwnames[] = {
25681 (char *) "id", NULL
25682 };
25683
25684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25685 if (obj0) {
25686 ecode1 = SWIG_AsVal_int(obj0, &val1);
25687 if (!SWIG_IsOK(ecode1)) {
25688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25689 }
25690 arg1 = static_cast< int >(val1);
25691 }
25692 {
25693 PyThreadState* __tstate = wxPyBeginAllowThreads();
25694 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25695 wxPyEndAllowThreads(__tstate);
25696 if (PyErr_Occurred()) SWIG_fail;
25697 }
25698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25706 PyObject *resultobj = 0;
25707 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25708 wxWindow *arg2 = (wxWindow *) 0 ;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 void *argp2 = 0 ;
25712 int res2 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 PyObject * obj1 = 0 ;
25715 char * kwnames[] = {
25716 (char *) "self",(char *) "win", NULL
25717 };
25718
25719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25721 if (!SWIG_IsOK(res1)) {
25722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25723 }
25724 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25726 if (!SWIG_IsOK(res2)) {
25727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25728 }
25729 arg2 = reinterpret_cast< wxWindow * >(argp2);
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 (arg1)->SetChangedWindow(arg2);
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 resultobj = SWIG_Py_Void();
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25744 PyObject *resultobj = 0;
25745 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25746 wxWindow *result = 0 ;
25747 void *argp1 = 0 ;
25748 int res1 = 0 ;
25749 PyObject *swig_obj[1] ;
25750
25751 if (!args) SWIG_fail;
25752 swig_obj[0] = args;
25753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25754 if (!SWIG_IsOK(res1)) {
25755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25756 }
25757 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25758 {
25759 PyThreadState* __tstate = wxPyBeginAllowThreads();
25760 result = (wxWindow *)(arg1)->GetChangedWindow();
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 {
25765 resultobj = wxPyMake_wxObject(result, (bool)0);
25766 }
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25774 PyObject *obj;
25775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25776 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25777 return SWIG_Py_Void();
25778 }
25779
25780 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25781 return SWIG_Python_InitShadowInstance(args);
25782 }
25783
25784 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25785 PyObject *resultobj = 0;
25786 int arg1 = (int) 0 ;
25787 wxQueryNewPaletteEvent *result = 0 ;
25788 int val1 ;
25789 int ecode1 = 0 ;
25790 PyObject * obj0 = 0 ;
25791 char * kwnames[] = {
25792 (char *) "winid", NULL
25793 };
25794
25795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25796 if (obj0) {
25797 ecode1 = SWIG_AsVal_int(obj0, &val1);
25798 if (!SWIG_IsOK(ecode1)) {
25799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25800 }
25801 arg1 = static_cast< int >(val1);
25802 }
25803 {
25804 PyThreadState* __tstate = wxPyBeginAllowThreads();
25805 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj = 0;
25818 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25819 bool arg2 ;
25820 void *argp1 = 0 ;
25821 int res1 = 0 ;
25822 bool val2 ;
25823 int ecode2 = 0 ;
25824 PyObject * obj0 = 0 ;
25825 PyObject * obj1 = 0 ;
25826 char * kwnames[] = {
25827 (char *) "self",(char *) "realized", NULL
25828 };
25829
25830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25832 if (!SWIG_IsOK(res1)) {
25833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25834 }
25835 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25837 if (!SWIG_IsOK(ecode2)) {
25838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25839 }
25840 arg2 = static_cast< bool >(val2);
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 (arg1)->SetPaletteRealized(arg2);
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 resultobj = SWIG_Py_Void();
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25855 PyObject *resultobj = 0;
25856 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25857 bool result;
25858 void *argp1 = 0 ;
25859 int res1 = 0 ;
25860 PyObject *swig_obj[1] ;
25861
25862 if (!args) SWIG_fail;
25863 swig_obj[0] = args;
25864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25865 if (!SWIG_IsOK(res1)) {
25866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25867 }
25868 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 {
25876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 PyObject *obj;
25886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25887 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25888 return SWIG_Py_Void();
25889 }
25890
25891 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25892 return SWIG_Python_InitShadowInstance(args);
25893 }
25894
25895 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25896 PyObject *resultobj = 0;
25897 wxNavigationKeyEvent *result = 0 ;
25898
25899 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25903 wxPyEndAllowThreads(__tstate);
25904 if (PyErr_Occurred()) SWIG_fail;
25905 }
25906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25914 PyObject *resultobj = 0;
25915 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25916 bool result;
25917 void *argp1 = 0 ;
25918 int res1 = 0 ;
25919 PyObject *swig_obj[1] ;
25920
25921 if (!args) SWIG_fail;
25922 swig_obj[0] = args;
25923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25924 if (!SWIG_IsOK(res1)) {
25925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25926 }
25927 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 {
25935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25936 }
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25944 PyObject *resultobj = 0;
25945 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25946 bool arg2 ;
25947 void *argp1 = 0 ;
25948 int res1 = 0 ;
25949 bool val2 ;
25950 int ecode2 = 0 ;
25951 PyObject * obj0 = 0 ;
25952 PyObject * obj1 = 0 ;
25953 char * kwnames[] = {
25954 (char *) "self",(char *) "forward", NULL
25955 };
25956
25957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25959 if (!SWIG_IsOK(res1)) {
25960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25961 }
25962 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25963 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25964 if (!SWIG_IsOK(ecode2)) {
25965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25966 }
25967 arg2 = static_cast< bool >(val2);
25968 {
25969 PyThreadState* __tstate = wxPyBeginAllowThreads();
25970 (arg1)->SetDirection(arg2);
25971 wxPyEndAllowThreads(__tstate);
25972 if (PyErr_Occurred()) SWIG_fail;
25973 }
25974 resultobj = SWIG_Py_Void();
25975 return resultobj;
25976 fail:
25977 return NULL;
25978 }
25979
25980
25981 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25982 PyObject *resultobj = 0;
25983 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25984 bool result;
25985 void *argp1 = 0 ;
25986 int res1 = 0 ;
25987 PyObject *swig_obj[1] ;
25988
25989 if (!args) SWIG_fail;
25990 swig_obj[0] = args;
25991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25992 if (!SWIG_IsOK(res1)) {
25993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25994 }
25995 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25996 {
25997 PyThreadState* __tstate = wxPyBeginAllowThreads();
25998 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25999 wxPyEndAllowThreads(__tstate);
26000 if (PyErr_Occurred()) SWIG_fail;
26001 }
26002 {
26003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26004 }
26005 return resultobj;
26006 fail:
26007 return NULL;
26008 }
26009
26010
26011 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26012 PyObject *resultobj = 0;
26013 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26014 bool arg2 ;
26015 void *argp1 = 0 ;
26016 int res1 = 0 ;
26017 bool val2 ;
26018 int ecode2 = 0 ;
26019 PyObject * obj0 = 0 ;
26020 PyObject * obj1 = 0 ;
26021 char * kwnames[] = {
26022 (char *) "self",(char *) "ischange", NULL
26023 };
26024
26025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26027 if (!SWIG_IsOK(res1)) {
26028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26029 }
26030 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26032 if (!SWIG_IsOK(ecode2)) {
26033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26034 }
26035 arg2 = static_cast< bool >(val2);
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 (arg1)->SetWindowChange(arg2);
26039 wxPyEndAllowThreads(__tstate);
26040 if (PyErr_Occurred()) SWIG_fail;
26041 }
26042 resultobj = SWIG_Py_Void();
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26050 PyObject *resultobj = 0;
26051 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26052 bool result;
26053 void *argp1 = 0 ;
26054 int res1 = 0 ;
26055 PyObject *swig_obj[1] ;
26056
26057 if (!args) SWIG_fail;
26058 swig_obj[0] = args;
26059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26060 if (!SWIG_IsOK(res1)) {
26061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26062 }
26063 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26064 {
26065 PyThreadState* __tstate = wxPyBeginAllowThreads();
26066 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26067 wxPyEndAllowThreads(__tstate);
26068 if (PyErr_Occurred()) SWIG_fail;
26069 }
26070 {
26071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26072 }
26073 return resultobj;
26074 fail:
26075 return NULL;
26076 }
26077
26078
26079 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26080 PyObject *resultobj = 0;
26081 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26082 bool arg2 ;
26083 void *argp1 = 0 ;
26084 int res1 = 0 ;
26085 bool val2 ;
26086 int ecode2 = 0 ;
26087 PyObject * obj0 = 0 ;
26088 PyObject * obj1 = 0 ;
26089 char * kwnames[] = {
26090 (char *) "self",(char *) "bIs", NULL
26091 };
26092
26093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26095 if (!SWIG_IsOK(res1)) {
26096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26097 }
26098 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26100 if (!SWIG_IsOK(ecode2)) {
26101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26102 }
26103 arg2 = static_cast< bool >(val2);
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 (arg1)->SetFromTab(arg2);
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 resultobj = SWIG_Py_Void();
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26118 PyObject *resultobj = 0;
26119 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26120 long arg2 ;
26121 void *argp1 = 0 ;
26122 int res1 = 0 ;
26123 long val2 ;
26124 int ecode2 = 0 ;
26125 PyObject * obj0 = 0 ;
26126 PyObject * obj1 = 0 ;
26127 char * kwnames[] = {
26128 (char *) "self",(char *) "flags", NULL
26129 };
26130
26131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26135 }
26136 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26137 ecode2 = SWIG_AsVal_long(obj1, &val2);
26138 if (!SWIG_IsOK(ecode2)) {
26139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26140 }
26141 arg2 = static_cast< long >(val2);
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 (arg1)->SetFlags(arg2);
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 resultobj = SWIG_Py_Void();
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26156 PyObject *resultobj = 0;
26157 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26158 wxWindow *result = 0 ;
26159 void *argp1 = 0 ;
26160 int res1 = 0 ;
26161 PyObject *swig_obj[1] ;
26162
26163 if (!args) SWIG_fail;
26164 swig_obj[0] = args;
26165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26166 if (!SWIG_IsOK(res1)) {
26167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26168 }
26169 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 {
26177 resultobj = wxPyMake_wxObject(result, (bool)0);
26178 }
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj = 0;
26187 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26188 wxWindow *arg2 = (wxWindow *) 0 ;
26189 void *argp1 = 0 ;
26190 int res1 = 0 ;
26191 void *argp2 = 0 ;
26192 int res2 = 0 ;
26193 PyObject * obj0 = 0 ;
26194 PyObject * obj1 = 0 ;
26195 char * kwnames[] = {
26196 (char *) "self",(char *) "win", NULL
26197 };
26198
26199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26201 if (!SWIG_IsOK(res1)) {
26202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26203 }
26204 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26206 if (!SWIG_IsOK(res2)) {
26207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26208 }
26209 arg2 = reinterpret_cast< wxWindow * >(argp2);
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 (arg1)->SetCurrentFocus(arg2);
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 resultobj = SWIG_Py_Void();
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26224 PyObject *obj;
26225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26226 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26227 return SWIG_Py_Void();
26228 }
26229
26230 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26231 return SWIG_Python_InitShadowInstance(args);
26232 }
26233
26234 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26235 PyObject *resultobj = 0;
26236 wxWindow *arg1 = (wxWindow *) NULL ;
26237 wxWindowCreateEvent *result = 0 ;
26238 void *argp1 = 0 ;
26239 int res1 = 0 ;
26240 PyObject * obj0 = 0 ;
26241 char * kwnames[] = {
26242 (char *) "win", NULL
26243 };
26244
26245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26246 if (obj0) {
26247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26248 if (!SWIG_IsOK(res1)) {
26249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26250 }
26251 arg1 = reinterpret_cast< wxWindow * >(argp1);
26252 }
26253 {
26254 PyThreadState* __tstate = wxPyBeginAllowThreads();
26255 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26256 wxPyEndAllowThreads(__tstate);
26257 if (PyErr_Occurred()) SWIG_fail;
26258 }
26259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26260 return resultobj;
26261 fail:
26262 return NULL;
26263 }
26264
26265
26266 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26267 PyObject *resultobj = 0;
26268 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26269 wxWindow *result = 0 ;
26270 void *argp1 = 0 ;
26271 int res1 = 0 ;
26272 PyObject *swig_obj[1] ;
26273
26274 if (!args) SWIG_fail;
26275 swig_obj[0] = args;
26276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26277 if (!SWIG_IsOK(res1)) {
26278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26279 }
26280 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 {
26288 resultobj = wxPyMake_wxObject(result, (bool)0);
26289 }
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *obj;
26298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26299 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26300 return SWIG_Py_Void();
26301 }
26302
26303 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 return SWIG_Python_InitShadowInstance(args);
26305 }
26306
26307 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxWindow *arg1 = (wxWindow *) NULL ;
26310 wxWindowDestroyEvent *result = 0 ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 PyObject * obj0 = 0 ;
26314 char * kwnames[] = {
26315 (char *) "win", NULL
26316 };
26317
26318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26319 if (obj0) {
26320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26321 if (!SWIG_IsOK(res1)) {
26322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26323 }
26324 arg1 = reinterpret_cast< wxWindow * >(argp1);
26325 }
26326 {
26327 PyThreadState* __tstate = wxPyBeginAllowThreads();
26328 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26329 wxPyEndAllowThreads(__tstate);
26330 if (PyErr_Occurred()) SWIG_fail;
26331 }
26332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26333 return resultobj;
26334 fail:
26335 return NULL;
26336 }
26337
26338
26339 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26340 PyObject *resultobj = 0;
26341 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26342 wxWindow *result = 0 ;
26343 void *argp1 = 0 ;
26344 int res1 = 0 ;
26345 PyObject *swig_obj[1] ;
26346
26347 if (!args) SWIG_fail;
26348 swig_obj[0] = args;
26349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26350 if (!SWIG_IsOK(res1)) {
26351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26352 }
26353 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = wxPyMake_wxObject(result, (bool)0);
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26370 PyObject *obj;
26371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26372 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26373 return SWIG_Py_Void();
26374 }
26375
26376 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 return SWIG_Python_InitShadowInstance(args);
26378 }
26379
26380 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj = 0;
26382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26383 int arg2 = (int) 0 ;
26384 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26385 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26386 wxContextMenuEvent *result = 0 ;
26387 int val1 ;
26388 int ecode1 = 0 ;
26389 int val2 ;
26390 int ecode2 = 0 ;
26391 wxPoint temp3 ;
26392 PyObject * obj0 = 0 ;
26393 PyObject * obj1 = 0 ;
26394 PyObject * obj2 = 0 ;
26395 char * kwnames[] = {
26396 (char *) "type",(char *) "winid",(char *) "pt", NULL
26397 };
26398
26399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26400 if (obj0) {
26401 ecode1 = SWIG_AsVal_int(obj0, &val1);
26402 if (!SWIG_IsOK(ecode1)) {
26403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26404 }
26405 arg1 = static_cast< wxEventType >(val1);
26406 }
26407 if (obj1) {
26408 ecode2 = SWIG_AsVal_int(obj1, &val2);
26409 if (!SWIG_IsOK(ecode2)) {
26410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26411 }
26412 arg2 = static_cast< int >(val2);
26413 }
26414 if (obj2) {
26415 {
26416 arg3 = &temp3;
26417 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26418 }
26419 }
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26427 return resultobj;
26428 fail:
26429 return NULL;
26430 }
26431
26432
26433 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26434 PyObject *resultobj = 0;
26435 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26436 wxPoint *result = 0 ;
26437 void *argp1 = 0 ;
26438 int res1 = 0 ;
26439 PyObject *swig_obj[1] ;
26440
26441 if (!args) SWIG_fail;
26442 swig_obj[0] = args;
26443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26444 if (!SWIG_IsOK(res1)) {
26445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26446 }
26447 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 {
26451 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26452 result = (wxPoint *) &_result_ref;
26453 }
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26465 PyObject *resultobj = 0;
26466 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26467 wxPoint *arg2 = 0 ;
26468 void *argp1 = 0 ;
26469 int res1 = 0 ;
26470 wxPoint temp2 ;
26471 PyObject * obj0 = 0 ;
26472 PyObject * obj1 = 0 ;
26473 char * kwnames[] = {
26474 (char *) "self",(char *) "pos", NULL
26475 };
26476
26477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26479 if (!SWIG_IsOK(res1)) {
26480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26481 }
26482 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26483 {
26484 arg2 = &temp2;
26485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26486 }
26487 {
26488 PyThreadState* __tstate = wxPyBeginAllowThreads();
26489 (arg1)->SetPosition((wxPoint const &)*arg2);
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 resultobj = SWIG_Py_Void();
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26501 PyObject *obj;
26502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26503 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26504 return SWIG_Py_Void();
26505 }
26506
26507 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26508 return SWIG_Python_InitShadowInstance(args);
26509 }
26510
26511 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26512 PyObject *resultobj = 0;
26513 wxIdleEvent *result = 0 ;
26514
26515 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 result = (wxIdleEvent *)new wxIdleEvent();
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj = 0;
26531 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26532 bool arg2 = (bool) true ;
26533 void *argp1 = 0 ;
26534 int res1 = 0 ;
26535 bool val2 ;
26536 int ecode2 = 0 ;
26537 PyObject * obj0 = 0 ;
26538 PyObject * obj1 = 0 ;
26539 char * kwnames[] = {
26540 (char *) "self",(char *) "needMore", NULL
26541 };
26542
26543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26545 if (!SWIG_IsOK(res1)) {
26546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26547 }
26548 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26549 if (obj1) {
26550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26551 if (!SWIG_IsOK(ecode2)) {
26552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26553 }
26554 arg2 = static_cast< bool >(val2);
26555 }
26556 {
26557 PyThreadState* __tstate = wxPyBeginAllowThreads();
26558 (arg1)->RequestMore(arg2);
26559 wxPyEndAllowThreads(__tstate);
26560 if (PyErr_Occurred()) SWIG_fail;
26561 }
26562 resultobj = SWIG_Py_Void();
26563 return resultobj;
26564 fail:
26565 return NULL;
26566 }
26567
26568
26569 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570 PyObject *resultobj = 0;
26571 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26572 bool result;
26573 void *argp1 = 0 ;
26574 int res1 = 0 ;
26575 PyObject *swig_obj[1] ;
26576
26577 if (!args) SWIG_fail;
26578 swig_obj[0] = args;
26579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26580 if (!SWIG_IsOK(res1)) {
26581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26582 }
26583 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26584 {
26585 PyThreadState* __tstate = wxPyBeginAllowThreads();
26586 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26587 wxPyEndAllowThreads(__tstate);
26588 if (PyErr_Occurred()) SWIG_fail;
26589 }
26590 {
26591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26592 }
26593 return resultobj;
26594 fail:
26595 return NULL;
26596 }
26597
26598
26599 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26600 PyObject *resultobj = 0;
26601 wxIdleMode arg1 ;
26602 int val1 ;
26603 int ecode1 = 0 ;
26604 PyObject * obj0 = 0 ;
26605 char * kwnames[] = {
26606 (char *) "mode", NULL
26607 };
26608
26609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26610 ecode1 = SWIG_AsVal_int(obj0, &val1);
26611 if (!SWIG_IsOK(ecode1)) {
26612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26613 }
26614 arg1 = static_cast< wxIdleMode >(val1);
26615 {
26616 PyThreadState* __tstate = wxPyBeginAllowThreads();
26617 wxIdleEvent::SetMode(arg1);
26618 wxPyEndAllowThreads(__tstate);
26619 if (PyErr_Occurred()) SWIG_fail;
26620 }
26621 resultobj = SWIG_Py_Void();
26622 return resultobj;
26623 fail:
26624 return NULL;
26625 }
26626
26627
26628 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26629 PyObject *resultobj = 0;
26630 wxIdleMode result;
26631
26632 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = (wxIdleMode)wxIdleEvent::GetMode();
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 resultobj = SWIG_From_int(static_cast< int >(result));
26640 return resultobj;
26641 fail:
26642 return NULL;
26643 }
26644
26645
26646 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj = 0;
26648 wxWindow *arg1 = (wxWindow *) 0 ;
26649 bool result;
26650 void *argp1 = 0 ;
26651 int res1 = 0 ;
26652 PyObject * obj0 = 0 ;
26653 char * kwnames[] = {
26654 (char *) "win", NULL
26655 };
26656
26657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26659 if (!SWIG_IsOK(res1)) {
26660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26661 }
26662 arg1 = reinterpret_cast< wxWindow * >(argp1);
26663 {
26664 PyThreadState* __tstate = wxPyBeginAllowThreads();
26665 result = (bool)wxIdleEvent::CanSend(arg1);
26666 wxPyEndAllowThreads(__tstate);
26667 if (PyErr_Occurred()) SWIG_fail;
26668 }
26669 {
26670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26671 }
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 PyObject *obj;
26680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26681 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26682 return SWIG_Py_Void();
26683 }
26684
26685 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26686 return SWIG_Python_InitShadowInstance(args);
26687 }
26688
26689 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26690 PyObject *resultobj = 0;
26691 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26692 int arg2 = (int) 0 ;
26693 wxClipboardTextEvent *result = 0 ;
26694 int val1 ;
26695 int ecode1 = 0 ;
26696 int val2 ;
26697 int ecode2 = 0 ;
26698 PyObject * obj0 = 0 ;
26699 PyObject * obj1 = 0 ;
26700 char * kwnames[] = {
26701 (char *) "type",(char *) "winid", NULL
26702 };
26703
26704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26705 if (obj0) {
26706 ecode1 = SWIG_AsVal_int(obj0, &val1);
26707 if (!SWIG_IsOK(ecode1)) {
26708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26709 }
26710 arg1 = static_cast< wxEventType >(val1);
26711 }
26712 if (obj1) {
26713 ecode2 = SWIG_AsVal_int(obj1, &val2);
26714 if (!SWIG_IsOK(ecode2)) {
26715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26716 }
26717 arg2 = static_cast< int >(val2);
26718 }
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26733 PyObject *obj;
26734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26735 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26736 return SWIG_Py_Void();
26737 }
26738
26739 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26740 return SWIG_Python_InitShadowInstance(args);
26741 }
26742
26743 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj = 0;
26745 int arg1 = (int) 0 ;
26746 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26747 wxPyEvent *result = 0 ;
26748 int val1 ;
26749 int ecode1 = 0 ;
26750 int val2 ;
26751 int ecode2 = 0 ;
26752 PyObject * obj0 = 0 ;
26753 PyObject * obj1 = 0 ;
26754 char * kwnames[] = {
26755 (char *) "winid",(char *) "eventType", NULL
26756 };
26757
26758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26759 if (obj0) {
26760 ecode1 = SWIG_AsVal_int(obj0, &val1);
26761 if (!SWIG_IsOK(ecode1)) {
26762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26763 }
26764 arg1 = static_cast< int >(val1);
26765 }
26766 if (obj1) {
26767 ecode2 = SWIG_AsVal_int(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26770 }
26771 arg2 = static_cast< wxEventType >(val2);
26772 }
26773 {
26774 PyThreadState* __tstate = wxPyBeginAllowThreads();
26775 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26776 wxPyEndAllowThreads(__tstate);
26777 if (PyErr_Occurred()) SWIG_fail;
26778 }
26779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26780 return resultobj;
26781 fail:
26782 return NULL;
26783 }
26784
26785
26786 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26787 PyObject *resultobj = 0;
26788 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26789 void *argp1 = 0 ;
26790 int res1 = 0 ;
26791 PyObject *swig_obj[1] ;
26792
26793 if (!args) SWIG_fail;
26794 swig_obj[0] = args;
26795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26796 if (!SWIG_IsOK(res1)) {
26797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26798 }
26799 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 delete arg1;
26803
26804 wxPyEndAllowThreads(__tstate);
26805 if (PyErr_Occurred()) SWIG_fail;
26806 }
26807 resultobj = SWIG_Py_Void();
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26815 PyObject *resultobj = 0;
26816 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26817 PyObject *arg2 = (PyObject *) 0 ;
26818 void *argp1 = 0 ;
26819 int res1 = 0 ;
26820 PyObject * obj0 = 0 ;
26821 PyObject * obj1 = 0 ;
26822 char * kwnames[] = {
26823 (char *) "self",(char *) "self", NULL
26824 };
26825
26826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26828 if (!SWIG_IsOK(res1)) {
26829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26830 }
26831 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26832 arg2 = obj1;
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 (arg1)->SetSelf(arg2);
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 resultobj = SWIG_Py_Void();
26840 return resultobj;
26841 fail:
26842 return NULL;
26843 }
26844
26845
26846 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26847 PyObject *resultobj = 0;
26848 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26849 PyObject *result = 0 ;
26850 void *argp1 = 0 ;
26851 int res1 = 0 ;
26852 PyObject *swig_obj[1] ;
26853
26854 if (!args) SWIG_fail;
26855 swig_obj[0] = args;
26856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26857 if (!SWIG_IsOK(res1)) {
26858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26859 }
26860 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 result = (PyObject *)(arg1)->GetSelf();
26864 wxPyEndAllowThreads(__tstate);
26865 if (PyErr_Occurred()) SWIG_fail;
26866 }
26867 resultobj = result;
26868 return resultobj;
26869 fail:
26870 return NULL;
26871 }
26872
26873
26874 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26875 PyObject *obj;
26876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26878 return SWIG_Py_Void();
26879 }
26880
26881 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26882 return SWIG_Python_InitShadowInstance(args);
26883 }
26884
26885 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26886 PyObject *resultobj = 0;
26887 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26888 int arg2 = (int) 0 ;
26889 wxPyCommandEvent *result = 0 ;
26890 int val1 ;
26891 int ecode1 = 0 ;
26892 int val2 ;
26893 int ecode2 = 0 ;
26894 PyObject * obj0 = 0 ;
26895 PyObject * obj1 = 0 ;
26896 char * kwnames[] = {
26897 (char *) "eventType",(char *) "id", NULL
26898 };
26899
26900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26901 if (obj0) {
26902 ecode1 = SWIG_AsVal_int(obj0, &val1);
26903 if (!SWIG_IsOK(ecode1)) {
26904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26905 }
26906 arg1 = static_cast< wxEventType >(val1);
26907 }
26908 if (obj1) {
26909 ecode2 = SWIG_AsVal_int(obj1, &val2);
26910 if (!SWIG_IsOK(ecode2)) {
26911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26912 }
26913 arg2 = static_cast< int >(val2);
26914 }
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26929 PyObject *resultobj = 0;
26930 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 PyObject *swig_obj[1] ;
26934
26935 if (!args) SWIG_fail;
26936 swig_obj[0] = args;
26937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26938 if (!SWIG_IsOK(res1)) {
26939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26940 }
26941 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 delete arg1;
26945
26946 wxPyEndAllowThreads(__tstate);
26947 if (PyErr_Occurred()) SWIG_fail;
26948 }
26949 resultobj = SWIG_Py_Void();
26950 return resultobj;
26951 fail:
26952 return NULL;
26953 }
26954
26955
26956 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26957 PyObject *resultobj = 0;
26958 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26959 PyObject *arg2 = (PyObject *) 0 ;
26960 void *argp1 = 0 ;
26961 int res1 = 0 ;
26962 PyObject * obj0 = 0 ;
26963 PyObject * obj1 = 0 ;
26964 char * kwnames[] = {
26965 (char *) "self",(char *) "self", NULL
26966 };
26967
26968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26970 if (!SWIG_IsOK(res1)) {
26971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26972 }
26973 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26974 arg2 = obj1;
26975 {
26976 PyThreadState* __tstate = wxPyBeginAllowThreads();
26977 (arg1)->SetSelf(arg2);
26978 wxPyEndAllowThreads(__tstate);
26979 if (PyErr_Occurred()) SWIG_fail;
26980 }
26981 resultobj = SWIG_Py_Void();
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26989 PyObject *resultobj = 0;
26990 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26991 PyObject *result = 0 ;
26992 void *argp1 = 0 ;
26993 int res1 = 0 ;
26994 PyObject *swig_obj[1] ;
26995
26996 if (!args) SWIG_fail;
26997 swig_obj[0] = args;
26998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26999 if (!SWIG_IsOK(res1)) {
27000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27001 }
27002 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27003 {
27004 PyThreadState* __tstate = wxPyBeginAllowThreads();
27005 result = (PyObject *)(arg1)->GetSelf();
27006 wxPyEndAllowThreads(__tstate);
27007 if (PyErr_Occurred()) SWIG_fail;
27008 }
27009 resultobj = result;
27010 return resultobj;
27011 fail:
27012 return NULL;
27013 }
27014
27015
27016 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27017 PyObject *obj;
27018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27019 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27020 return SWIG_Py_Void();
27021 }
27022
27023 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27024 return SWIG_Python_InitShadowInstance(args);
27025 }
27026
27027 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27028 PyObject *resultobj = 0;
27029 wxWindow *arg1 = (wxWindow *) 0 ;
27030 wxDateTime *arg2 = 0 ;
27031 wxEventType arg3 ;
27032 wxDateEvent *result = 0 ;
27033 void *argp1 = 0 ;
27034 int res1 = 0 ;
27035 void *argp2 = 0 ;
27036 int res2 = 0 ;
27037 int val3 ;
27038 int ecode3 = 0 ;
27039 PyObject * obj0 = 0 ;
27040 PyObject * obj1 = 0 ;
27041 PyObject * obj2 = 0 ;
27042 char * kwnames[] = {
27043 (char *) "win",(char *) "dt",(char *) "type", NULL
27044 };
27045
27046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27048 if (!SWIG_IsOK(res1)) {
27049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27050 }
27051 arg1 = reinterpret_cast< wxWindow * >(argp1);
27052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27053 if (!SWIG_IsOK(res2)) {
27054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27055 }
27056 if (!argp2) {
27057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27058 }
27059 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27060 ecode3 = SWIG_AsVal_int(obj2, &val3);
27061 if (!SWIG_IsOK(ecode3)) {
27062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27063 }
27064 arg3 = static_cast< wxEventType >(val3);
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27068 wxPyEndAllowThreads(__tstate);
27069 if (PyErr_Occurred()) SWIG_fail;
27070 }
27071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27072 return resultobj;
27073 fail:
27074 return NULL;
27075 }
27076
27077
27078 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27079 PyObject *resultobj = 0;
27080 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27081 wxDateTime *result = 0 ;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 PyObject *swig_obj[1] ;
27085
27086 if (!args) SWIG_fail;
27087 swig_obj[0] = args;
27088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27089 if (!SWIG_IsOK(res1)) {
27090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27091 }
27092 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27093 {
27094 PyThreadState* __tstate = wxPyBeginAllowThreads();
27095 {
27096 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27097 result = (wxDateTime *) &_result_ref;
27098 }
27099 wxPyEndAllowThreads(__tstate);
27100 if (PyErr_Occurred()) SWIG_fail;
27101 }
27102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27103 return resultobj;
27104 fail:
27105 return NULL;
27106 }
27107
27108
27109 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27110 PyObject *resultobj = 0;
27111 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27112 wxDateTime *arg2 = 0 ;
27113 void *argp1 = 0 ;
27114 int res1 = 0 ;
27115 void *argp2 = 0 ;
27116 int res2 = 0 ;
27117 PyObject * obj0 = 0 ;
27118 PyObject * obj1 = 0 ;
27119 char * kwnames[] = {
27120 (char *) "self",(char *) "date", NULL
27121 };
27122
27123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27125 if (!SWIG_IsOK(res1)) {
27126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27127 }
27128 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27130 if (!SWIG_IsOK(res2)) {
27131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27132 }
27133 if (!argp2) {
27134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27135 }
27136 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 (arg1)->SetDate((wxDateTime const &)*arg2);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 resultobj = SWIG_Py_Void();
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27151 PyObject *obj;
27152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27153 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27154 return SWIG_Py_Void();
27155 }
27156
27157 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27158 return SWIG_Python_InitShadowInstance(args);
27159 }
27160
27161 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27162 PyObject *resultobj = 0;
27163 wxPyApp *result = 0 ;
27164
27165 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27166 {
27167 PyThreadState* __tstate = wxPyBeginAllowThreads();
27168 result = (wxPyApp *)new_wxPyApp();
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27173 return resultobj;
27174 fail:
27175 return NULL;
27176 }
27177
27178
27179 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27180 PyObject *resultobj = 0;
27181 wxPyApp *arg1 = (wxPyApp *) 0 ;
27182 void *argp1 = 0 ;
27183 int res1 = 0 ;
27184 PyObject *swig_obj[1] ;
27185
27186 if (!args) SWIG_fail;
27187 swig_obj[0] = args;
27188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27189 if (!SWIG_IsOK(res1)) {
27190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27191 }
27192 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 delete arg1;
27196
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 resultobj = SWIG_Py_Void();
27201 return resultobj;
27202 fail:
27203 return NULL;
27204 }
27205
27206
27207 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27208 PyObject *resultobj = 0;
27209 wxPyApp *arg1 = (wxPyApp *) 0 ;
27210 PyObject *arg2 = (PyObject *) 0 ;
27211 PyObject *arg3 = (PyObject *) 0 ;
27212 bool arg4 ;
27213 void *argp1 = 0 ;
27214 int res1 = 0 ;
27215 bool val4 ;
27216 int ecode4 = 0 ;
27217 PyObject * obj0 = 0 ;
27218 PyObject * obj1 = 0 ;
27219 PyObject * obj2 = 0 ;
27220 PyObject * obj3 = 0 ;
27221 char * kwnames[] = {
27222 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27223 };
27224
27225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27227 if (!SWIG_IsOK(res1)) {
27228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27229 }
27230 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27231 arg2 = obj1;
27232 arg3 = obj2;
27233 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27234 if (!SWIG_IsOK(ecode4)) {
27235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27236 }
27237 arg4 = static_cast< bool >(val4);
27238 {
27239 PyThreadState* __tstate = wxPyBeginAllowThreads();
27240 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 resultobj = SWIG_Py_Void();
27245 return resultobj;
27246 fail:
27247 return NULL;
27248 }
27249
27250
27251 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27252 PyObject *resultobj = 0;
27253 wxPyApp *arg1 = (wxPyApp *) 0 ;
27254 wxString result;
27255 void *argp1 = 0 ;
27256 int res1 = 0 ;
27257 PyObject *swig_obj[1] ;
27258
27259 if (!args) SWIG_fail;
27260 swig_obj[0] = args;
27261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27262 if (!SWIG_IsOK(res1)) {
27263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27264 }
27265 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = ((wxPyApp const *)arg1)->GetAppName();
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 #if wxUSE_UNICODE
27274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27275 #else
27276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27277 #endif
27278 }
27279 return resultobj;
27280 fail:
27281 return NULL;
27282 }
27283
27284
27285 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27286 PyObject *resultobj = 0;
27287 wxPyApp *arg1 = (wxPyApp *) 0 ;
27288 wxString *arg2 = 0 ;
27289 void *argp1 = 0 ;
27290 int res1 = 0 ;
27291 bool temp2 = false ;
27292 PyObject * obj0 = 0 ;
27293 PyObject * obj1 = 0 ;
27294 char * kwnames[] = {
27295 (char *) "self",(char *) "name", NULL
27296 };
27297
27298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27300 if (!SWIG_IsOK(res1)) {
27301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27302 }
27303 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27304 {
27305 arg2 = wxString_in_helper(obj1);
27306 if (arg2 == NULL) SWIG_fail;
27307 temp2 = true;
27308 }
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 (arg1)->SetAppName((wxString const &)*arg2);
27312 wxPyEndAllowThreads(__tstate);
27313 if (PyErr_Occurred()) SWIG_fail;
27314 }
27315 resultobj = SWIG_Py_Void();
27316 {
27317 if (temp2)
27318 delete arg2;
27319 }
27320 return resultobj;
27321 fail:
27322 {
27323 if (temp2)
27324 delete arg2;
27325 }
27326 return NULL;
27327 }
27328
27329
27330 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27331 PyObject *resultobj = 0;
27332 wxPyApp *arg1 = (wxPyApp *) 0 ;
27333 wxString result;
27334 void *argp1 = 0 ;
27335 int res1 = 0 ;
27336 PyObject *swig_obj[1] ;
27337
27338 if (!args) SWIG_fail;
27339 swig_obj[0] = args;
27340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27341 if (!SWIG_IsOK(res1)) {
27342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27343 }
27344 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27345 {
27346 PyThreadState* __tstate = wxPyBeginAllowThreads();
27347 result = ((wxPyApp const *)arg1)->GetClassName();
27348 wxPyEndAllowThreads(__tstate);
27349 if (PyErr_Occurred()) SWIG_fail;
27350 }
27351 {
27352 #if wxUSE_UNICODE
27353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27354 #else
27355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27356 #endif
27357 }
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27365 PyObject *resultobj = 0;
27366 wxPyApp *arg1 = (wxPyApp *) 0 ;
27367 wxString *arg2 = 0 ;
27368 void *argp1 = 0 ;
27369 int res1 = 0 ;
27370 bool temp2 = false ;
27371 PyObject * obj0 = 0 ;
27372 PyObject * obj1 = 0 ;
27373 char * kwnames[] = {
27374 (char *) "self",(char *) "name", NULL
27375 };
27376
27377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27379 if (!SWIG_IsOK(res1)) {
27380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27381 }
27382 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27383 {
27384 arg2 = wxString_in_helper(obj1);
27385 if (arg2 == NULL) SWIG_fail;
27386 temp2 = true;
27387 }
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 (arg1)->SetClassName((wxString const &)*arg2);
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 resultobj = SWIG_Py_Void();
27395 {
27396 if (temp2)
27397 delete arg2;
27398 }
27399 return resultobj;
27400 fail:
27401 {
27402 if (temp2)
27403 delete arg2;
27404 }
27405 return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27410 PyObject *resultobj = 0;
27411 wxPyApp *arg1 = (wxPyApp *) 0 ;
27412 wxString *result = 0 ;
27413 void *argp1 = 0 ;
27414 int res1 = 0 ;
27415 PyObject *swig_obj[1] ;
27416
27417 if (!args) SWIG_fail;
27418 swig_obj[0] = args;
27419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27420 if (!SWIG_IsOK(res1)) {
27421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27422 }
27423 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27424 {
27425 PyThreadState* __tstate = wxPyBeginAllowThreads();
27426 {
27427 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27428 result = (wxString *) &_result_ref;
27429 }
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 #if wxUSE_UNICODE
27435 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27436 #else
27437 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27438 #endif
27439 }
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj = 0;
27448 wxPyApp *arg1 = (wxPyApp *) 0 ;
27449 wxString *arg2 = 0 ;
27450 void *argp1 = 0 ;
27451 int res1 = 0 ;
27452 bool temp2 = false ;
27453 PyObject * obj0 = 0 ;
27454 PyObject * obj1 = 0 ;
27455 char * kwnames[] = {
27456 (char *) "self",(char *) "name", NULL
27457 };
27458
27459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27461 if (!SWIG_IsOK(res1)) {
27462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27463 }
27464 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27465 {
27466 arg2 = wxString_in_helper(obj1);
27467 if (arg2 == NULL) SWIG_fail;
27468 temp2 = true;
27469 }
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 (arg1)->SetVendorName((wxString const &)*arg2);
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 resultobj = SWIG_Py_Void();
27477 {
27478 if (temp2)
27479 delete arg2;
27480 }
27481 return resultobj;
27482 fail:
27483 {
27484 if (temp2)
27485 delete arg2;
27486 }
27487 return NULL;
27488 }
27489
27490
27491 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27492 PyObject *resultobj = 0;
27493 wxPyApp *arg1 = (wxPyApp *) 0 ;
27494 wxAppTraits *result = 0 ;
27495 void *argp1 = 0 ;
27496 int res1 = 0 ;
27497 PyObject *swig_obj[1] ;
27498
27499 if (!args) SWIG_fail;
27500 swig_obj[0] = args;
27501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27502 if (!SWIG_IsOK(res1)) {
27503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27504 }
27505 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (wxAppTraits *)(arg1)->GetTraits();
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27513 return resultobj;
27514 fail:
27515 return NULL;
27516 }
27517
27518
27519 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27520 PyObject *resultobj = 0;
27521 wxPyApp *arg1 = (wxPyApp *) 0 ;
27522 void *argp1 = 0 ;
27523 int res1 = 0 ;
27524 PyObject *swig_obj[1] ;
27525
27526 if (!args) SWIG_fail;
27527 swig_obj[0] = args;
27528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27529 if (!SWIG_IsOK(res1)) {
27530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27531 }
27532 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27533 {
27534 PyThreadState* __tstate = wxPyBeginAllowThreads();
27535 (arg1)->ProcessPendingEvents();
27536 wxPyEndAllowThreads(__tstate);
27537 if (PyErr_Occurred()) SWIG_fail;
27538 }
27539 resultobj = SWIG_Py_Void();
27540 return resultobj;
27541 fail:
27542 return NULL;
27543 }
27544
27545
27546 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27547 PyObject *resultobj = 0;
27548 wxPyApp *arg1 = (wxPyApp *) 0 ;
27549 bool arg2 = (bool) false ;
27550 bool result;
27551 void *argp1 = 0 ;
27552 int res1 = 0 ;
27553 bool val2 ;
27554 int ecode2 = 0 ;
27555 PyObject * obj0 = 0 ;
27556 PyObject * obj1 = 0 ;
27557 char * kwnames[] = {
27558 (char *) "self",(char *) "onlyIfNeeded", NULL
27559 };
27560
27561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27563 if (!SWIG_IsOK(res1)) {
27564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27565 }
27566 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27567 if (obj1) {
27568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27569 if (!SWIG_IsOK(ecode2)) {
27570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27571 }
27572 arg2 = static_cast< bool >(val2);
27573 }
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 result = (bool)(arg1)->Yield(arg2);
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 {
27581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27582 }
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27590 PyObject *resultobj = 0;
27591 wxPyApp *arg1 = (wxPyApp *) 0 ;
27592 void *argp1 = 0 ;
27593 int res1 = 0 ;
27594 PyObject *swig_obj[1] ;
27595
27596 if (!args) SWIG_fail;
27597 swig_obj[0] = args;
27598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27599 if (!SWIG_IsOK(res1)) {
27600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27601 }
27602 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 (arg1)->WakeUpIdle();
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 resultobj = SWIG_Py_Void();
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27617 PyObject *resultobj = 0;
27618 bool result;
27619
27620 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27621 {
27622 PyThreadState* __tstate = wxPyBeginAllowThreads();
27623 result = (bool)wxPyApp::IsMainLoopRunning();
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 {
27628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27629 }
27630 return resultobj;
27631 fail:
27632 return NULL;
27633 }
27634
27635
27636 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27637 PyObject *resultobj = 0;
27638 wxPyApp *arg1 = (wxPyApp *) 0 ;
27639 int result;
27640 void *argp1 = 0 ;
27641 int res1 = 0 ;
27642 PyObject *swig_obj[1] ;
27643
27644 if (!args) SWIG_fail;
27645 swig_obj[0] = args;
27646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27647 if (!SWIG_IsOK(res1)) {
27648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27649 }
27650 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (int)(arg1)->MainLoop();
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 resultobj = SWIG_From_int(static_cast< int >(result));
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27665 PyObject *resultobj = 0;
27666 wxPyApp *arg1 = (wxPyApp *) 0 ;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 PyObject *swig_obj[1] ;
27670
27671 if (!args) SWIG_fail;
27672 swig_obj[0] = args;
27673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27674 if (!SWIG_IsOK(res1)) {
27675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27676 }
27677 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 (arg1)->Exit();
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 resultobj = SWIG_Py_Void();
27685 return resultobj;
27686 fail:
27687 return NULL;
27688 }
27689
27690
27691 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27692 PyObject *resultobj = 0;
27693 wxPyApp *arg1 = (wxPyApp *) 0 ;
27694 void *argp1 = 0 ;
27695 int res1 = 0 ;
27696 PyObject *swig_obj[1] ;
27697
27698 if (!args) SWIG_fail;
27699 swig_obj[0] = args;
27700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27701 if (!SWIG_IsOK(res1)) {
27702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27703 }
27704 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 (arg1)->ExitMainLoop();
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 resultobj = SWIG_Py_Void();
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27719 PyObject *resultobj = 0;
27720 wxPyApp *arg1 = (wxPyApp *) 0 ;
27721 bool result;
27722 void *argp1 = 0 ;
27723 int res1 = 0 ;
27724 PyObject *swig_obj[1] ;
27725
27726 if (!args) SWIG_fail;
27727 swig_obj[0] = args;
27728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27729 if (!SWIG_IsOK(res1)) {
27730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27731 }
27732 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (bool)(arg1)->Pending();
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 {
27740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27741 }
27742 return resultobj;
27743 fail:
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27749 PyObject *resultobj = 0;
27750 wxPyApp *arg1 = (wxPyApp *) 0 ;
27751 bool result;
27752 void *argp1 = 0 ;
27753 int res1 = 0 ;
27754 PyObject *swig_obj[1] ;
27755
27756 if (!args) SWIG_fail;
27757 swig_obj[0] = args;
27758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27759 if (!SWIG_IsOK(res1)) {
27760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27761 }
27762 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = (bool)(arg1)->Dispatch();
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 {
27770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27771 }
27772 return resultobj;
27773 fail:
27774 return NULL;
27775 }
27776
27777
27778 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27779 PyObject *resultobj = 0;
27780 wxPyApp *arg1 = (wxPyApp *) 0 ;
27781 bool result;
27782 void *argp1 = 0 ;
27783 int res1 = 0 ;
27784 PyObject *swig_obj[1] ;
27785
27786 if (!args) SWIG_fail;
27787 swig_obj[0] = args;
27788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27789 if (!SWIG_IsOK(res1)) {
27790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27791 }
27792 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = (bool)(arg1)->ProcessIdle();
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 {
27800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27801 }
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27809 PyObject *resultobj = 0;
27810 wxPyApp *arg1 = (wxPyApp *) 0 ;
27811 wxWindow *arg2 = (wxWindow *) 0 ;
27812 wxIdleEvent *arg3 = 0 ;
27813 bool result;
27814 void *argp1 = 0 ;
27815 int res1 = 0 ;
27816 void *argp2 = 0 ;
27817 int res2 = 0 ;
27818 void *argp3 = 0 ;
27819 int res3 = 0 ;
27820 PyObject * obj0 = 0 ;
27821 PyObject * obj1 = 0 ;
27822 PyObject * obj2 = 0 ;
27823 char * kwnames[] = {
27824 (char *) "self",(char *) "win",(char *) "event", NULL
27825 };
27826
27827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27829 if (!SWIG_IsOK(res1)) {
27830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27831 }
27832 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27834 if (!SWIG_IsOK(res2)) {
27835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27836 }
27837 arg2 = reinterpret_cast< wxWindow * >(argp2);
27838 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27839 if (!SWIG_IsOK(res3)) {
27840 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27841 }
27842 if (!argp3) {
27843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27844 }
27845 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 {
27853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27854 }
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27862 PyObject *resultobj = 0;
27863 wxPyApp *arg1 = (wxPyApp *) 0 ;
27864 bool result;
27865 void *argp1 = 0 ;
27866 int res1 = 0 ;
27867 PyObject *swig_obj[1] ;
27868
27869 if (!args) SWIG_fail;
27870 swig_obj[0] = args;
27871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27872 if (!SWIG_IsOK(res1)) {
27873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27874 }
27875 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 result = (bool)((wxPyApp const *)arg1)->IsActive();
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 {
27883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27884 }
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27892 PyObject *resultobj = 0;
27893 wxPyApp *arg1 = (wxPyApp *) 0 ;
27894 wxWindow *arg2 = (wxWindow *) 0 ;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 void *argp2 = 0 ;
27898 int res2 = 0 ;
27899 PyObject * obj0 = 0 ;
27900 PyObject * obj1 = 0 ;
27901 char * kwnames[] = {
27902 (char *) "self",(char *) "win", NULL
27903 };
27904
27905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27907 if (!SWIG_IsOK(res1)) {
27908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27909 }
27910 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27912 if (!SWIG_IsOK(res2)) {
27913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27914 }
27915 arg2 = reinterpret_cast< wxWindow * >(argp2);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 (arg1)->SetTopWindow(arg2);
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 resultobj = SWIG_Py_Void();
27923 return resultobj;
27924 fail:
27925 return NULL;
27926 }
27927
27928
27929 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27930 PyObject *resultobj = 0;
27931 wxPyApp *arg1 = (wxPyApp *) 0 ;
27932 wxWindow *result = 0 ;
27933 void *argp1 = 0 ;
27934 int res1 = 0 ;
27935 PyObject *swig_obj[1] ;
27936
27937 if (!args) SWIG_fail;
27938 swig_obj[0] = args;
27939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27940 if (!SWIG_IsOK(res1)) {
27941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27942 }
27943 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 {
27951 resultobj = wxPyMake_wxObject(result, (bool)0);
27952 }
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj = 0;
27961 wxPyApp *arg1 = (wxPyApp *) 0 ;
27962 bool arg2 ;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 bool val2 ;
27966 int ecode2 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 PyObject * obj1 = 0 ;
27969 char * kwnames[] = {
27970 (char *) "self",(char *) "flag", NULL
27971 };
27972
27973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27975 if (!SWIG_IsOK(res1)) {
27976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27977 }
27978 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27980 if (!SWIG_IsOK(ecode2)) {
27981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27982 }
27983 arg2 = static_cast< bool >(val2);
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 (arg1)->SetExitOnFrameDelete(arg2);
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 resultobj = SWIG_Py_Void();
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27998 PyObject *resultobj = 0;
27999 wxPyApp *arg1 = (wxPyApp *) 0 ;
28000 bool result;
28001 void *argp1 = 0 ;
28002 int res1 = 0 ;
28003 PyObject *swig_obj[1] ;
28004
28005 if (!args) SWIG_fail;
28006 swig_obj[0] = args;
28007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28008 if (!SWIG_IsOK(res1)) {
28009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28010 }
28011 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28015 wxPyEndAllowThreads(__tstate);
28016 if (PyErr_Occurred()) SWIG_fail;
28017 }
28018 {
28019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28020 }
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28028 PyObject *resultobj = 0;
28029 wxPyApp *arg1 = (wxPyApp *) 0 ;
28030 bool arg2 ;
28031 void *argp1 = 0 ;
28032 int res1 = 0 ;
28033 bool val2 ;
28034 int ecode2 = 0 ;
28035 PyObject * obj0 = 0 ;
28036 PyObject * obj1 = 0 ;
28037 char * kwnames[] = {
28038 (char *) "self",(char *) "flag", NULL
28039 };
28040
28041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28043 if (!SWIG_IsOK(res1)) {
28044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28045 }
28046 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28048 if (!SWIG_IsOK(ecode2)) {
28049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28050 }
28051 arg2 = static_cast< bool >(val2);
28052 {
28053 PyThreadState* __tstate = wxPyBeginAllowThreads();
28054 (arg1)->SetUseBestVisual(arg2);
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 resultobj = SWIG_Py_Void();
28059 return resultobj;
28060 fail:
28061 return NULL;
28062 }
28063
28064
28065 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28066 PyObject *resultobj = 0;
28067 wxPyApp *arg1 = (wxPyApp *) 0 ;
28068 bool result;
28069 void *argp1 = 0 ;
28070 int res1 = 0 ;
28071 PyObject *swig_obj[1] ;
28072
28073 if (!args) SWIG_fail;
28074 swig_obj[0] = args;
28075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28076 if (!SWIG_IsOK(res1)) {
28077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28078 }
28079 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28080 {
28081 PyThreadState* __tstate = wxPyBeginAllowThreads();
28082 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28083 wxPyEndAllowThreads(__tstate);
28084 if (PyErr_Occurred()) SWIG_fail;
28085 }
28086 {
28087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28088 }
28089 return resultobj;
28090 fail:
28091 return NULL;
28092 }
28093
28094
28095 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28096 PyObject *resultobj = 0;
28097 wxPyApp *arg1 = (wxPyApp *) 0 ;
28098 int arg2 ;
28099 void *argp1 = 0 ;
28100 int res1 = 0 ;
28101 int val2 ;
28102 int ecode2 = 0 ;
28103 PyObject * obj0 = 0 ;
28104 PyObject * obj1 = 0 ;
28105 char * kwnames[] = {
28106 (char *) "self",(char *) "mode", NULL
28107 };
28108
28109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28111 if (!SWIG_IsOK(res1)) {
28112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28113 }
28114 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28115 ecode2 = SWIG_AsVal_int(obj1, &val2);
28116 if (!SWIG_IsOK(ecode2)) {
28117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28118 }
28119 arg2 = static_cast< int >(val2);
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 (arg1)->SetPrintMode(arg2);
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 resultobj = SWIG_Py_Void();
28127 return resultobj;
28128 fail:
28129 return NULL;
28130 }
28131
28132
28133 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28134 PyObject *resultobj = 0;
28135 wxPyApp *arg1 = (wxPyApp *) 0 ;
28136 int result;
28137 void *argp1 = 0 ;
28138 int res1 = 0 ;
28139 PyObject *swig_obj[1] ;
28140
28141 if (!args) SWIG_fail;
28142 swig_obj[0] = args;
28143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28144 if (!SWIG_IsOK(res1)) {
28145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28146 }
28147 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_From_int(static_cast< int >(result));
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxPyApp *arg1 = (wxPyApp *) 0 ;
28164 int arg2 ;
28165 void *argp1 = 0 ;
28166 int res1 = 0 ;
28167 int val2 ;
28168 int ecode2 = 0 ;
28169 PyObject * obj0 = 0 ;
28170 PyObject * obj1 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "self",(char *) "mode", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28179 }
28180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28181 ecode2 = SWIG_AsVal_int(obj1, &val2);
28182 if (!SWIG_IsOK(ecode2)) {
28183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28184 }
28185 arg2 = static_cast< int >(val2);
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 (arg1)->SetAssertMode(arg2);
28189 wxPyEndAllowThreads(__tstate);
28190 if (PyErr_Occurred()) SWIG_fail;
28191 }
28192 resultobj = SWIG_Py_Void();
28193 return resultobj;
28194 fail:
28195 return NULL;
28196 }
28197
28198
28199 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28200 PyObject *resultobj = 0;
28201 wxPyApp *arg1 = (wxPyApp *) 0 ;
28202 int result;
28203 void *argp1 = 0 ;
28204 int res1 = 0 ;
28205 PyObject *swig_obj[1] ;
28206
28207 if (!args) SWIG_fail;
28208 swig_obj[0] = args;
28209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28210 if (!SWIG_IsOK(res1)) {
28211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28212 }
28213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (int)(arg1)->GetAssertMode();
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_From_int(static_cast< int >(result));
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28228 PyObject *resultobj = 0;
28229 bool result;
28230
28231 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28232 {
28233 PyThreadState* __tstate = wxPyBeginAllowThreads();
28234 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28235 wxPyEndAllowThreads(__tstate);
28236 if (PyErr_Occurred()) SWIG_fail;
28237 }
28238 {
28239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28240 }
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28248 PyObject *resultobj = 0;
28249 long result;
28250
28251 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28252 {
28253 PyThreadState* __tstate = wxPyBeginAllowThreads();
28254 result = (long)wxPyApp::GetMacAboutMenuItemId();
28255 wxPyEndAllowThreads(__tstate);
28256 if (PyErr_Occurred()) SWIG_fail;
28257 }
28258 resultobj = SWIG_From_long(static_cast< long >(result));
28259 return resultobj;
28260 fail:
28261 return NULL;
28262 }
28263
28264
28265 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28266 PyObject *resultobj = 0;
28267 long result;
28268
28269 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28273 wxPyEndAllowThreads(__tstate);
28274 if (PyErr_Occurred()) SWIG_fail;
28275 }
28276 resultobj = SWIG_From_long(static_cast< long >(result));
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28284 PyObject *resultobj = 0;
28285 long result;
28286
28287 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 result = (long)wxPyApp::GetMacExitMenuItemId();
28291 wxPyEndAllowThreads(__tstate);
28292 if (PyErr_Occurred()) SWIG_fail;
28293 }
28294 resultobj = SWIG_From_long(static_cast< long >(result));
28295 return resultobj;
28296 fail:
28297 return NULL;
28298 }
28299
28300
28301 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28302 PyObject *resultobj = 0;
28303 wxString result;
28304
28305 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = wxPyApp::GetMacHelpMenuTitleName();
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 {
28313 #if wxUSE_UNICODE
28314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28315 #else
28316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28317 #endif
28318 }
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28326 PyObject *resultobj = 0;
28327 bool arg1 ;
28328 bool val1 ;
28329 int ecode1 = 0 ;
28330 PyObject * obj0 = 0 ;
28331 char * kwnames[] = {
28332 (char *) "val", NULL
28333 };
28334
28335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28336 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28337 if (!SWIG_IsOK(ecode1)) {
28338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28339 }
28340 arg1 = static_cast< bool >(val1);
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 resultobj = SWIG_Py_Void();
28348 return resultobj;
28349 fail:
28350 return NULL;
28351 }
28352
28353
28354 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28355 PyObject *resultobj = 0;
28356 long arg1 ;
28357 long val1 ;
28358 int ecode1 = 0 ;
28359 PyObject * obj0 = 0 ;
28360 char * kwnames[] = {
28361 (char *) "val", NULL
28362 };
28363
28364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28365 ecode1 = SWIG_AsVal_long(obj0, &val1);
28366 if (!SWIG_IsOK(ecode1)) {
28367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28368 }
28369 arg1 = static_cast< long >(val1);
28370 {
28371 PyThreadState* __tstate = wxPyBeginAllowThreads();
28372 wxPyApp::SetMacAboutMenuItemId(arg1);
28373 wxPyEndAllowThreads(__tstate);
28374 if (PyErr_Occurred()) SWIG_fail;
28375 }
28376 resultobj = SWIG_Py_Void();
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj = 0;
28385 long arg1 ;
28386 long val1 ;
28387 int ecode1 = 0 ;
28388 PyObject * obj0 = 0 ;
28389 char * kwnames[] = {
28390 (char *) "val", NULL
28391 };
28392
28393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28394 ecode1 = SWIG_AsVal_long(obj0, &val1);
28395 if (!SWIG_IsOK(ecode1)) {
28396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28397 }
28398 arg1 = static_cast< long >(val1);
28399 {
28400 PyThreadState* __tstate = wxPyBeginAllowThreads();
28401 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 resultobj = SWIG_Py_Void();
28406 return resultobj;
28407 fail:
28408 return NULL;
28409 }
28410
28411
28412 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28413 PyObject *resultobj = 0;
28414 long arg1 ;
28415 long val1 ;
28416 int ecode1 = 0 ;
28417 PyObject * obj0 = 0 ;
28418 char * kwnames[] = {
28419 (char *) "val", NULL
28420 };
28421
28422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28423 ecode1 = SWIG_AsVal_long(obj0, &val1);
28424 if (!SWIG_IsOK(ecode1)) {
28425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28426 }
28427 arg1 = static_cast< long >(val1);
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 wxPyApp::SetMacExitMenuItemId(arg1);
28431 wxPyEndAllowThreads(__tstate);
28432 if (PyErr_Occurred()) SWIG_fail;
28433 }
28434 resultobj = SWIG_Py_Void();
28435 return resultobj;
28436 fail:
28437 return NULL;
28438 }
28439
28440
28441 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28442 PyObject *resultobj = 0;
28443 wxString *arg1 = 0 ;
28444 bool temp1 = false ;
28445 PyObject * obj0 = 0 ;
28446 char * kwnames[] = {
28447 (char *) "val", NULL
28448 };
28449
28450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28451 {
28452 arg1 = wxString_in_helper(obj0);
28453 if (arg1 == NULL) SWIG_fail;
28454 temp1 = true;
28455 }
28456 {
28457 PyThreadState* __tstate = wxPyBeginAllowThreads();
28458 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28459 wxPyEndAllowThreads(__tstate);
28460 if (PyErr_Occurred()) SWIG_fail;
28461 }
28462 resultobj = SWIG_Py_Void();
28463 {
28464 if (temp1)
28465 delete arg1;
28466 }
28467 return resultobj;
28468 fail:
28469 {
28470 if (temp1)
28471 delete arg1;
28472 }
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28478 PyObject *resultobj = 0;
28479 wxPyApp *arg1 = (wxPyApp *) 0 ;
28480 void *argp1 = 0 ;
28481 int res1 = 0 ;
28482 PyObject *swig_obj[1] ;
28483
28484 if (!args) SWIG_fail;
28485 swig_obj[0] = args;
28486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28487 if (!SWIG_IsOK(res1)) {
28488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28489 }
28490 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 (arg1)->_BootstrapApp();
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 resultobj = SWIG_Py_Void();
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *resultobj = 0;
28506 int result;
28507
28508 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (int)wxPyApp::GetComCtl32Version();
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 resultobj = SWIG_From_int(static_cast< int >(result));
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28523 PyObject *resultobj = 0;
28524 bool result;
28525
28526 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 result = (bool)wxPyApp_DisplayAvailable();
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 {
28534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28535 }
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28543 PyObject *obj;
28544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28546 return SWIG_Py_Void();
28547 }
28548
28549 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28550 return SWIG_Python_InitShadowInstance(args);
28551 }
28552
28553 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28554 PyObject *resultobj = 0;
28555
28556 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 wxExit();
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 resultobj = SWIG_Py_Void();
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28571 PyObject *resultobj = 0;
28572 bool result;
28573
28574 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (bool)wxYield();
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 {
28582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28583 }
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28591 PyObject *resultobj = 0;
28592 bool result;
28593
28594 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 result = (bool)wxYieldIfNeeded();
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 {
28602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28603 }
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj = 0;
28612 wxWindow *arg1 = (wxWindow *) NULL ;
28613 bool arg2 = (bool) false ;
28614 bool result;
28615 void *argp1 = 0 ;
28616 int res1 = 0 ;
28617 bool val2 ;
28618 int ecode2 = 0 ;
28619 PyObject * obj0 = 0 ;
28620 PyObject * obj1 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "win",(char *) "onlyIfNeeded", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28626 if (obj0) {
28627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28628 if (!SWIG_IsOK(res1)) {
28629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28630 }
28631 arg1 = reinterpret_cast< wxWindow * >(argp1);
28632 }
28633 if (obj1) {
28634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28635 if (!SWIG_IsOK(ecode2)) {
28636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28637 }
28638 arg2 = static_cast< bool >(val2);
28639 }
28640 {
28641 PyThreadState* __tstate = wxPyBeginAllowThreads();
28642 result = (bool)wxSafeYield(arg1,arg2);
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 {
28647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28648 }
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28656 PyObject *resultobj = 0;
28657
28658 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 wxWakeUpIdle();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_Py_Void();
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj = 0;
28674 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28675 wxEvent *arg2 = 0 ;
28676 void *argp1 = 0 ;
28677 int res1 = 0 ;
28678 void *argp2 = 0 ;
28679 int res2 = 0 ;
28680 PyObject * obj0 = 0 ;
28681 PyObject * obj1 = 0 ;
28682 char * kwnames[] = {
28683 (char *) "dest",(char *) "event", NULL
28684 };
28685
28686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28688 if (!SWIG_IsOK(res1)) {
28689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28690 }
28691 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28692 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28693 if (!SWIG_IsOK(res2)) {
28694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28695 }
28696 if (!argp2) {
28697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28698 }
28699 arg2 = reinterpret_cast< wxEvent * >(argp2);
28700 {
28701 PyThreadState* __tstate = wxPyBeginAllowThreads();
28702 wxPostEvent(arg1,*arg2);
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 resultobj = SWIG_Py_Void();
28707 return resultobj;
28708 fail:
28709 return NULL;
28710 }
28711
28712
28713 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28714 PyObject *resultobj = 0;
28715
28716 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 wxApp_CleanUp();
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 resultobj = SWIG_Py_Void();
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *resultobj = 0;
28732 wxPyApp *result = 0 ;
28733
28734 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (wxPyApp *)wxPyGetApp();
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 {
28742 resultobj = wxPyMake_wxObject(result, 0);
28743 }
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj = 0;
28752 char *arg1 = (char *) 0 ;
28753 int res1 ;
28754 char *buf1 = 0 ;
28755 int alloc1 = 0 ;
28756 PyObject * obj0 = 0 ;
28757 char * kwnames[] = {
28758 (char *) "encoding", NULL
28759 };
28760
28761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28762 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28763 if (!SWIG_IsOK(res1)) {
28764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28765 }
28766 arg1 = buf1;
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 wxSetDefaultPyEncoding((char const *)arg1);
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_Py_Void();
28774 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28775 return resultobj;
28776 fail:
28777 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28778 return NULL;
28779 }
28780
28781
28782 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28783 PyObject *resultobj = 0;
28784 char *result = 0 ;
28785
28786 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28787 {
28788 PyThreadState* __tstate = wxPyBeginAllowThreads();
28789 result = (char *)wxGetDefaultPyEncoding();
28790 wxPyEndAllowThreads(__tstate);
28791 if (PyErr_Occurred()) SWIG_fail;
28792 }
28793 resultobj = SWIG_FromCharPtr(result);
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28801 PyObject *resultobj = 0;
28802 wxEventLoop *result = 0 ;
28803
28804 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28805 {
28806 PyThreadState* __tstate = wxPyBeginAllowThreads();
28807 result = (wxEventLoop *)new wxEventLoop();
28808 wxPyEndAllowThreads(__tstate);
28809 if (PyErr_Occurred()) SWIG_fail;
28810 }
28811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28812 return resultobj;
28813 fail:
28814 return NULL;
28815 }
28816
28817
28818 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28819 PyObject *resultobj = 0;
28820 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28821 void *argp1 = 0 ;
28822 int res1 = 0 ;
28823 PyObject *swig_obj[1] ;
28824
28825 if (!args) SWIG_fail;
28826 swig_obj[0] = args;
28827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28828 if (!SWIG_IsOK(res1)) {
28829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28830 }
28831 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28832 {
28833 PyThreadState* __tstate = wxPyBeginAllowThreads();
28834 delete arg1;
28835
28836 wxPyEndAllowThreads(__tstate);
28837 if (PyErr_Occurred()) SWIG_fail;
28838 }
28839 resultobj = SWIG_Py_Void();
28840 return resultobj;
28841 fail:
28842 return NULL;
28843 }
28844
28845
28846 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28847 PyObject *resultobj = 0;
28848 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28849 int result;
28850 void *argp1 = 0 ;
28851 int res1 = 0 ;
28852 PyObject *swig_obj[1] ;
28853
28854 if (!args) SWIG_fail;
28855 swig_obj[0] = args;
28856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28859 }
28860 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 result = (int)(arg1)->Run();
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_From_int(static_cast< int >(result));
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj = 0;
28876 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28877 int arg2 = (int) 0 ;
28878 void *argp1 = 0 ;
28879 int res1 = 0 ;
28880 int val2 ;
28881 int ecode2 = 0 ;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 char * kwnames[] = {
28885 (char *) "self",(char *) "rc", NULL
28886 };
28887
28888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28892 }
28893 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28894 if (obj1) {
28895 ecode2 = SWIG_AsVal_int(obj1, &val2);
28896 if (!SWIG_IsOK(ecode2)) {
28897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28898 }
28899 arg2 = static_cast< int >(val2);
28900 }
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 (arg1)->Exit(arg2);
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 resultobj = SWIG_Py_Void();
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28915 PyObject *resultobj = 0;
28916 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28917 bool result;
28918 void *argp1 = 0 ;
28919 int res1 = 0 ;
28920 PyObject *swig_obj[1] ;
28921
28922 if (!args) SWIG_fail;
28923 swig_obj[0] = args;
28924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28927 }
28928 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 result = (bool)((wxEventLoop const *)arg1)->Pending();
28932 wxPyEndAllowThreads(__tstate);
28933 if (PyErr_Occurred()) SWIG_fail;
28934 }
28935 {
28936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28937 }
28938 return resultobj;
28939 fail:
28940 return NULL;
28941 }
28942
28943
28944 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28945 PyObject *resultobj = 0;
28946 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28947 bool result;
28948 void *argp1 = 0 ;
28949 int res1 = 0 ;
28950 PyObject *swig_obj[1] ;
28951
28952 if (!args) SWIG_fail;
28953 swig_obj[0] = args;
28954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28955 if (!SWIG_IsOK(res1)) {
28956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28957 }
28958 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28959 {
28960 PyThreadState* __tstate = wxPyBeginAllowThreads();
28961 result = (bool)(arg1)->Dispatch();
28962 wxPyEndAllowThreads(__tstate);
28963 if (PyErr_Occurred()) SWIG_fail;
28964 }
28965 {
28966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28967 }
28968 return resultobj;
28969 fail:
28970 return NULL;
28971 }
28972
28973
28974 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28975 PyObject *resultobj = 0;
28976 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28977 bool result;
28978 void *argp1 = 0 ;
28979 int res1 = 0 ;
28980 PyObject *swig_obj[1] ;
28981
28982 if (!args) SWIG_fail;
28983 swig_obj[0] = args;
28984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28985 if (!SWIG_IsOK(res1)) {
28986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28987 }
28988 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28989 {
28990 PyThreadState* __tstate = wxPyBeginAllowThreads();
28991 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28992 wxPyEndAllowThreads(__tstate);
28993 if (PyErr_Occurred()) SWIG_fail;
28994 }
28995 {
28996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28997 }
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29005 PyObject *resultobj = 0;
29006 wxEventLoop *result = 0 ;
29007
29008 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29009 {
29010 PyThreadState* __tstate = wxPyBeginAllowThreads();
29011 result = (wxEventLoop *)wxEventLoop::GetActive();
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29023 PyObject *resultobj = 0;
29024 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29025 void *argp1 = 0 ;
29026 int res1 = 0 ;
29027 PyObject * obj0 = 0 ;
29028 char * kwnames[] = {
29029 (char *) "loop", NULL
29030 };
29031
29032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29034 if (!SWIG_IsOK(res1)) {
29035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29036 }
29037 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 wxEventLoop::SetActive(arg1);
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 resultobj = SWIG_Py_Void();
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29052 PyObject *obj;
29053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29054 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29055 return SWIG_Py_Void();
29056 }
29057
29058 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29059 return SWIG_Python_InitShadowInstance(args);
29060 }
29061
29062 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj = 0;
29064 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29065 wxEventLoopActivator *result = 0 ;
29066 void *argp1 = 0 ;
29067 int res1 = 0 ;
29068 PyObject * obj0 = 0 ;
29069 char * kwnames[] = {
29070 (char *) "evtLoop", NULL
29071 };
29072
29073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29075 if (!SWIG_IsOK(res1)) {
29076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29077 }
29078 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29093 PyObject *resultobj = 0;
29094 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29095 void *argp1 = 0 ;
29096 int res1 = 0 ;
29097 PyObject *swig_obj[1] ;
29098
29099 if (!args) SWIG_fail;
29100 swig_obj[0] = args;
29101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29102 if (!SWIG_IsOK(res1)) {
29103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29104 }
29105 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 delete arg1;
29109
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 resultobj = SWIG_Py_Void();
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29121 PyObject *obj;
29122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29123 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29124 return SWIG_Py_Void();
29125 }
29126
29127 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29128 return SWIG_Python_InitShadowInstance(args);
29129 }
29130
29131 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj = 0;
29133 int arg1 = (int) 0 ;
29134 int arg2 = (int) 0 ;
29135 int arg3 = (int) 0 ;
29136 wxAcceleratorEntry *result = 0 ;
29137 int val1 ;
29138 int ecode1 = 0 ;
29139 int val2 ;
29140 int ecode2 = 0 ;
29141 int val3 ;
29142 int ecode3 = 0 ;
29143 PyObject * obj0 = 0 ;
29144 PyObject * obj1 = 0 ;
29145 PyObject * obj2 = 0 ;
29146 char * kwnames[] = {
29147 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29148 };
29149
29150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29151 if (obj0) {
29152 ecode1 = SWIG_AsVal_int(obj0, &val1);
29153 if (!SWIG_IsOK(ecode1)) {
29154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29155 }
29156 arg1 = static_cast< int >(val1);
29157 }
29158 if (obj1) {
29159 ecode2 = SWIG_AsVal_int(obj1, &val2);
29160 if (!SWIG_IsOK(ecode2)) {
29161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29162 }
29163 arg2 = static_cast< int >(val2);
29164 }
29165 if (obj2) {
29166 ecode3 = SWIG_AsVal_int(obj2, &val3);
29167 if (!SWIG_IsOK(ecode3)) {
29168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29169 }
29170 arg3 = static_cast< int >(val3);
29171 }
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29186 PyObject *resultobj = 0;
29187 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 PyObject *swig_obj[1] ;
29191
29192 if (!args) SWIG_fail;
29193 swig_obj[0] = args;
29194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29195 if (!SWIG_IsOK(res1)) {
29196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29197 }
29198 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 delete arg1;
29202
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 resultobj = SWIG_Py_Void();
29207 return resultobj;
29208 fail:
29209 return NULL;
29210 }
29211
29212
29213 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29214 PyObject *resultobj = 0;
29215 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29216 int arg2 ;
29217 int arg3 ;
29218 int arg4 ;
29219 void *argp1 = 0 ;
29220 int res1 = 0 ;
29221 int val2 ;
29222 int ecode2 = 0 ;
29223 int val3 ;
29224 int ecode3 = 0 ;
29225 int val4 ;
29226 int ecode4 = 0 ;
29227 PyObject * obj0 = 0 ;
29228 PyObject * obj1 = 0 ;
29229 PyObject * obj2 = 0 ;
29230 PyObject * obj3 = 0 ;
29231 char * kwnames[] = {
29232 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29233 };
29234
29235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29237 if (!SWIG_IsOK(res1)) {
29238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29239 }
29240 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29241 ecode2 = SWIG_AsVal_int(obj1, &val2);
29242 if (!SWIG_IsOK(ecode2)) {
29243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29244 }
29245 arg2 = static_cast< int >(val2);
29246 ecode3 = SWIG_AsVal_int(obj2, &val3);
29247 if (!SWIG_IsOK(ecode3)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29249 }
29250 arg3 = static_cast< int >(val3);
29251 ecode4 = SWIG_AsVal_int(obj3, &val4);
29252 if (!SWIG_IsOK(ecode4)) {
29253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29254 }
29255 arg4 = static_cast< int >(val4);
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 (arg1)->Set(arg2,arg3,arg4);
29259 wxPyEndAllowThreads(__tstate);
29260 if (PyErr_Occurred()) SWIG_fail;
29261 }
29262 resultobj = SWIG_Py_Void();
29263 return resultobj;
29264 fail:
29265 return NULL;
29266 }
29267
29268
29269 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29270 PyObject *resultobj = 0;
29271 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29272 int result;
29273 void *argp1 = 0 ;
29274 int res1 = 0 ;
29275 PyObject *swig_obj[1] ;
29276
29277 if (!args) SWIG_fail;
29278 swig_obj[0] = args;
29279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29280 if (!SWIG_IsOK(res1)) {
29281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29282 }
29283 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29284 {
29285 PyThreadState* __tstate = wxPyBeginAllowThreads();
29286 result = (int)(arg1)->GetFlags();
29287 wxPyEndAllowThreads(__tstate);
29288 if (PyErr_Occurred()) SWIG_fail;
29289 }
29290 resultobj = SWIG_From_int(static_cast< int >(result));
29291 return resultobj;
29292 fail:
29293 return NULL;
29294 }
29295
29296
29297 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29298 PyObject *resultobj = 0;
29299 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29300 int result;
29301 void *argp1 = 0 ;
29302 int res1 = 0 ;
29303 PyObject *swig_obj[1] ;
29304
29305 if (!args) SWIG_fail;
29306 swig_obj[0] = args;
29307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29308 if (!SWIG_IsOK(res1)) {
29309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29310 }
29311 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29312 {
29313 PyThreadState* __tstate = wxPyBeginAllowThreads();
29314 result = (int)(arg1)->GetKeyCode();
29315 wxPyEndAllowThreads(__tstate);
29316 if (PyErr_Occurred()) SWIG_fail;
29317 }
29318 resultobj = SWIG_From_int(static_cast< int >(result));
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29326 PyObject *resultobj = 0;
29327 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29328 int result;
29329 void *argp1 = 0 ;
29330 int res1 = 0 ;
29331 PyObject *swig_obj[1] ;
29332
29333 if (!args) SWIG_fail;
29334 swig_obj[0] = args;
29335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29336 if (!SWIG_IsOK(res1)) {
29337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29338 }
29339 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29340 {
29341 PyThreadState* __tstate = wxPyBeginAllowThreads();
29342 result = (int)(arg1)->GetCommand();
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 resultobj = SWIG_From_int(static_cast< int >(result));
29347 return resultobj;
29348 fail:
29349 return NULL;
29350 }
29351
29352
29353 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29354 PyObject *obj;
29355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29356 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29357 return SWIG_Py_Void();
29358 }
29359
29360 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29361 return SWIG_Python_InitShadowInstance(args);
29362 }
29363
29364 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj = 0;
29366 int arg1 ;
29367 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29368 wxAcceleratorTable *result = 0 ;
29369 PyObject * obj0 = 0 ;
29370 char * kwnames[] = {
29371 (char *) "n", NULL
29372 };
29373
29374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29375 {
29376 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29377 if (arg2) arg1 = PyList_Size(obj0);
29378 else arg1 = 0;
29379 }
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *resultobj = 0;
29395 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29396 void *argp1 = 0 ;
29397 int res1 = 0 ;
29398 PyObject *swig_obj[1] ;
29399
29400 if (!args) SWIG_fail;
29401 swig_obj[0] = args;
29402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29403 if (!SWIG_IsOK(res1)) {
29404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29405 }
29406 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 delete arg1;
29410
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 resultobj = SWIG_Py_Void();
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29422 PyObject *resultobj = 0;
29423 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29424 bool result;
29425 void *argp1 = 0 ;
29426 int res1 = 0 ;
29427 PyObject *swig_obj[1] ;
29428
29429 if (!args) SWIG_fail;
29430 swig_obj[0] = args;
29431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29432 if (!SWIG_IsOK(res1)) {
29433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29434 }
29435 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29436 {
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 {
29443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29444 }
29445 return resultobj;
29446 fail:
29447 return NULL;
29448 }
29449
29450
29451 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29452 PyObject *obj;
29453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29454 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29455 return SWIG_Py_Void();
29456 }
29457
29458 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 return SWIG_Python_InitShadowInstance(args);
29460 }
29461
29462 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29463 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29464 return 1;
29465 }
29466
29467
29468 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29469 PyObject *pyobj = 0;
29470
29471 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29472 return pyobj;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = 0;
29478 wxString *arg1 = 0 ;
29479 wxAcceleratorEntry *result = 0 ;
29480 bool temp1 = false ;
29481 PyObject * obj0 = 0 ;
29482 char * kwnames[] = {
29483 (char *) "label", NULL
29484 };
29485
29486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29487 {
29488 arg1 = wxString_in_helper(obj0);
29489 if (arg1 == NULL) SWIG_fail;
29490 temp1 = true;
29491 }
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29499 {
29500 if (temp1)
29501 delete arg1;
29502 }
29503 return resultobj;
29504 fail:
29505 {
29506 if (temp1)
29507 delete arg1;
29508 }
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN int PanelNameStr_set(PyObject *) {
29514 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29515 return 1;
29516 }
29517
29518
29519 SWIGINTERN PyObject *PanelNameStr_get(void) {
29520 PyObject *pyobj = 0;
29521
29522 {
29523 #if wxUSE_UNICODE
29524 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29525 #else
29526 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29527 #endif
29528 }
29529 return pyobj;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29534 PyObject *resultobj = 0;
29535 wxVisualAttributes *result = 0 ;
29536
29537 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (wxVisualAttributes *)new_wxVisualAttributes();
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29545 return resultobj;
29546 fail:
29547 return NULL;
29548 }
29549
29550
29551 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29552 PyObject *resultobj = 0;
29553 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29554 void *argp1 = 0 ;
29555 int res1 = 0 ;
29556 PyObject *swig_obj[1] ;
29557
29558 if (!args) SWIG_fail;
29559 swig_obj[0] = args;
29560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29561 if (!SWIG_IsOK(res1)) {
29562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29563 }
29564 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 delete_wxVisualAttributes(arg1);
29568
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_Py_Void();
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29580 PyObject *resultobj = 0;
29581 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29582 wxFont *arg2 = (wxFont *) 0 ;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 void *argp2 = 0 ;
29586 int res2 = 0 ;
29587 PyObject *swig_obj[2] ;
29588
29589 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29593 }
29594 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29595 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29596 if (!SWIG_IsOK(res2)) {
29597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29598 }
29599 arg2 = reinterpret_cast< wxFont * >(argp2);
29600 if (arg1) (arg1)->font = *arg2;
29601
29602 resultobj = SWIG_Py_Void();
29603 return resultobj;
29604 fail:
29605 return NULL;
29606 }
29607
29608
29609 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29610 PyObject *resultobj = 0;
29611 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29612 wxFont *result = 0 ;
29613 void *argp1 = 0 ;
29614 int res1 = 0 ;
29615 PyObject *swig_obj[1] ;
29616
29617 if (!args) SWIG_fail;
29618 swig_obj[0] = args;
29619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29620 if (!SWIG_IsOK(res1)) {
29621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29622 }
29623 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29624 result = (wxFont *)& ((arg1)->font);
29625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29633 PyObject *resultobj = 0;
29634 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29635 wxColour *arg2 = (wxColour *) 0 ;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 void *argp2 = 0 ;
29639 int res2 = 0 ;
29640 PyObject *swig_obj[2] ;
29641
29642 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29644 if (!SWIG_IsOK(res1)) {
29645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29646 }
29647 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29648 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29649 if (!SWIG_IsOK(res2)) {
29650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29651 }
29652 arg2 = reinterpret_cast< wxColour * >(argp2);
29653 if (arg1) (arg1)->colFg = *arg2;
29654
29655 resultobj = SWIG_Py_Void();
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29663 PyObject *resultobj = 0;
29664 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29665 wxColour *result = 0 ;
29666 void *argp1 = 0 ;
29667 int res1 = 0 ;
29668 PyObject *swig_obj[1] ;
29669
29670 if (!args) SWIG_fail;
29671 swig_obj[0] = args;
29672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29675 }
29676 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29677 result = (wxColour *)& ((arg1)->colFg);
29678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29686 PyObject *resultobj = 0;
29687 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29688 wxColour *arg2 = (wxColour *) 0 ;
29689 void *argp1 = 0 ;
29690 int res1 = 0 ;
29691 void *argp2 = 0 ;
29692 int res2 = 0 ;
29693 PyObject *swig_obj[2] ;
29694
29695 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29697 if (!SWIG_IsOK(res1)) {
29698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29699 }
29700 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29701 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29702 if (!SWIG_IsOK(res2)) {
29703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29704 }
29705 arg2 = reinterpret_cast< wxColour * >(argp2);
29706 if (arg1) (arg1)->colBg = *arg2;
29707
29708 resultobj = SWIG_Py_Void();
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29716 PyObject *resultobj = 0;
29717 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29718 wxColour *result = 0 ;
29719 void *argp1 = 0 ;
29720 int res1 = 0 ;
29721 PyObject *swig_obj[1] ;
29722
29723 if (!args) SWIG_fail;
29724 swig_obj[0] = args;
29725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29726 if (!SWIG_IsOK(res1)) {
29727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29728 }
29729 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29730 result = (wxColour *)& ((arg1)->colBg);
29731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29732 return resultobj;
29733 fail:
29734 return NULL;
29735 }
29736
29737
29738 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29739 PyObject *obj;
29740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29741 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29742 return SWIG_Py_Void();
29743 }
29744
29745 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29746 return SWIG_Python_InitShadowInstance(args);
29747 }
29748
29749 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj = 0;
29751 wxWindow *arg1 = (wxWindow *) 0 ;
29752 int arg2 = (int) (int)-1 ;
29753 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29754 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29755 wxSize const &arg4_defvalue = wxDefaultSize ;
29756 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29757 long arg5 = (long) 0 ;
29758 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29759 wxString *arg6 = (wxString *) &arg6_defvalue ;
29760 wxWindow *result = 0 ;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 int val2 ;
29764 int ecode2 = 0 ;
29765 wxPoint temp3 ;
29766 wxSize temp4 ;
29767 long val5 ;
29768 int ecode5 = 0 ;
29769 bool temp6 = false ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 PyObject * obj3 = 0 ;
29774 PyObject * obj4 = 0 ;
29775 PyObject * obj5 = 0 ;
29776 char * kwnames[] = {
29777 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29778 };
29779
29780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29784 }
29785 arg1 = reinterpret_cast< wxWindow * >(argp1);
29786 if (obj1) {
29787 ecode2 = SWIG_AsVal_int(obj1, &val2);
29788 if (!SWIG_IsOK(ecode2)) {
29789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29790 }
29791 arg2 = static_cast< int >(val2);
29792 }
29793 if (obj2) {
29794 {
29795 arg3 = &temp3;
29796 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29797 }
29798 }
29799 if (obj3) {
29800 {
29801 arg4 = &temp4;
29802 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29803 }
29804 }
29805 if (obj4) {
29806 ecode5 = SWIG_AsVal_long(obj4, &val5);
29807 if (!SWIG_IsOK(ecode5)) {
29808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29809 }
29810 arg5 = static_cast< long >(val5);
29811 }
29812 if (obj5) {
29813 {
29814 arg6 = wxString_in_helper(obj5);
29815 if (arg6 == NULL) SWIG_fail;
29816 temp6 = true;
29817 }
29818 }
29819 {
29820 if (!wxPyCheckForApp()) SWIG_fail;
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29827 {
29828 if (temp6)
29829 delete arg6;
29830 }
29831 return resultobj;
29832 fail:
29833 {
29834 if (temp6)
29835 delete arg6;
29836 }
29837 return NULL;
29838 }
29839
29840
29841 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29842 PyObject *resultobj = 0;
29843 wxWindow *result = 0 ;
29844
29845 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29846 {
29847 if (!wxPyCheckForApp()) SWIG_fail;
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 result = (wxWindow *)new wxWindow();
29850 wxPyEndAllowThreads(__tstate);
29851 if (PyErr_Occurred()) SWIG_fail;
29852 }
29853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29854 return resultobj;
29855 fail:
29856 return NULL;
29857 }
29858
29859
29860 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29861 PyObject *resultobj = 0;
29862 wxWindow *arg1 = (wxWindow *) 0 ;
29863 wxWindow *arg2 = (wxWindow *) 0 ;
29864 int arg3 = (int) (int)-1 ;
29865 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29866 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29867 wxSize const &arg5_defvalue = wxDefaultSize ;
29868 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29869 long arg6 = (long) 0 ;
29870 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29871 wxString *arg7 = (wxString *) &arg7_defvalue ;
29872 bool result;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 void *argp2 = 0 ;
29876 int res2 = 0 ;
29877 int val3 ;
29878 int ecode3 = 0 ;
29879 wxPoint temp4 ;
29880 wxSize temp5 ;
29881 long val6 ;
29882 int ecode6 = 0 ;
29883 bool temp7 = false ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 PyObject * obj2 = 0 ;
29887 PyObject * obj3 = 0 ;
29888 PyObject * obj4 = 0 ;
29889 PyObject * obj5 = 0 ;
29890 PyObject * obj6 = 0 ;
29891 char * kwnames[] = {
29892 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29893 };
29894
29895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29897 if (!SWIG_IsOK(res1)) {
29898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29899 }
29900 arg1 = reinterpret_cast< wxWindow * >(argp1);
29901 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29902 if (!SWIG_IsOK(res2)) {
29903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29904 }
29905 arg2 = reinterpret_cast< wxWindow * >(argp2);
29906 if (obj2) {
29907 ecode3 = SWIG_AsVal_int(obj2, &val3);
29908 if (!SWIG_IsOK(ecode3)) {
29909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29910 }
29911 arg3 = static_cast< int >(val3);
29912 }
29913 if (obj3) {
29914 {
29915 arg4 = &temp4;
29916 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29917 }
29918 }
29919 if (obj4) {
29920 {
29921 arg5 = &temp5;
29922 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29923 }
29924 }
29925 if (obj5) {
29926 ecode6 = SWIG_AsVal_long(obj5, &val6);
29927 if (!SWIG_IsOK(ecode6)) {
29928 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29929 }
29930 arg6 = static_cast< long >(val6);
29931 }
29932 if (obj6) {
29933 {
29934 arg7 = wxString_in_helper(obj6);
29935 if (arg7 == NULL) SWIG_fail;
29936 temp7 = true;
29937 }
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 {
29946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29947 }
29948 {
29949 if (temp7)
29950 delete arg7;
29951 }
29952 return resultobj;
29953 fail:
29954 {
29955 if (temp7)
29956 delete arg7;
29957 }
29958 return NULL;
29959 }
29960
29961
29962 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29963 PyObject *resultobj = 0;
29964 wxWindow *arg1 = (wxWindow *) 0 ;
29965 bool arg2 = (bool) false ;
29966 bool result;
29967 void *argp1 = 0 ;
29968 int res1 = 0 ;
29969 bool val2 ;
29970 int ecode2 = 0 ;
29971 PyObject * obj0 = 0 ;
29972 PyObject * obj1 = 0 ;
29973 char * kwnames[] = {
29974 (char *) "self",(char *) "force", NULL
29975 };
29976
29977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29979 if (!SWIG_IsOK(res1)) {
29980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29981 }
29982 arg1 = reinterpret_cast< wxWindow * >(argp1);
29983 if (obj1) {
29984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29985 if (!SWIG_IsOK(ecode2)) {
29986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29987 }
29988 arg2 = static_cast< bool >(val2);
29989 }
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 result = (bool)(arg1)->Close(arg2);
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 {
29997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29998 }
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30006 PyObject *resultobj = 0;
30007 wxWindow *arg1 = (wxWindow *) 0 ;
30008 bool result;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 PyObject *swig_obj[1] ;
30012
30013 if (!args) SWIG_fail;
30014 swig_obj[0] = args;
30015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30016 if (!SWIG_IsOK(res1)) {
30017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30018 }
30019 arg1 = reinterpret_cast< wxWindow * >(argp1);
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = (bool)(arg1)->Destroy();
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 {
30027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30028 }
30029 return resultobj;
30030 fail:
30031 return NULL;
30032 }
30033
30034
30035 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30036 PyObject *resultobj = 0;
30037 wxWindow *arg1 = (wxWindow *) 0 ;
30038 bool result;
30039 void *argp1 = 0 ;
30040 int res1 = 0 ;
30041 PyObject *swig_obj[1] ;
30042
30043 if (!args) SWIG_fail;
30044 swig_obj[0] = args;
30045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30046 if (!SWIG_IsOK(res1)) {
30047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30048 }
30049 arg1 = reinterpret_cast< wxWindow * >(argp1);
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = (bool)(arg1)->DestroyChildren();
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 {
30057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30058 }
30059 return resultobj;
30060 fail:
30061 return NULL;
30062 }
30063
30064
30065 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30066 PyObject *resultobj = 0;
30067 wxWindow *arg1 = (wxWindow *) 0 ;
30068 bool result;
30069 void *argp1 = 0 ;
30070 int res1 = 0 ;
30071 PyObject *swig_obj[1] ;
30072
30073 if (!args) SWIG_fail;
30074 swig_obj[0] = args;
30075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30076 if (!SWIG_IsOK(res1)) {
30077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30078 }
30079 arg1 = reinterpret_cast< wxWindow * >(argp1);
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 {
30087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30088 }
30089 return resultobj;
30090 fail:
30091 return NULL;
30092 }
30093
30094
30095 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30096 PyObject *resultobj = 0;
30097 wxWindow *arg1 = (wxWindow *) 0 ;
30098 wxString *arg2 = 0 ;
30099 void *argp1 = 0 ;
30100 int res1 = 0 ;
30101 bool temp2 = false ;
30102 PyObject * obj0 = 0 ;
30103 PyObject * obj1 = 0 ;
30104 char * kwnames[] = {
30105 (char *) "self",(char *) "label", NULL
30106 };
30107
30108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30110 if (!SWIG_IsOK(res1)) {
30111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30112 }
30113 arg1 = reinterpret_cast< wxWindow * >(argp1);
30114 {
30115 arg2 = wxString_in_helper(obj1);
30116 if (arg2 == NULL) SWIG_fail;
30117 temp2 = true;
30118 }
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 (arg1)->SetLabel((wxString const &)*arg2);
30122 wxPyEndAllowThreads(__tstate);
30123 if (PyErr_Occurred()) SWIG_fail;
30124 }
30125 resultobj = SWIG_Py_Void();
30126 {
30127 if (temp2)
30128 delete arg2;
30129 }
30130 return resultobj;
30131 fail:
30132 {
30133 if (temp2)
30134 delete arg2;
30135 }
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30141 PyObject *resultobj = 0;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 wxString result;
30144 void *argp1 = 0 ;
30145 int res1 = 0 ;
30146 PyObject *swig_obj[1] ;
30147
30148 if (!args) SWIG_fail;
30149 swig_obj[0] = args;
30150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30151 if (!SWIG_IsOK(res1)) {
30152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30153 }
30154 arg1 = reinterpret_cast< wxWindow * >(argp1);
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = ((wxWindow const *)arg1)->GetLabel();
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 {
30162 #if wxUSE_UNICODE
30163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30164 #else
30165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30166 #endif
30167 }
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj = 0;
30176 wxWindow *arg1 = (wxWindow *) 0 ;
30177 wxString *arg2 = 0 ;
30178 void *argp1 = 0 ;
30179 int res1 = 0 ;
30180 bool temp2 = false ;
30181 PyObject * obj0 = 0 ;
30182 PyObject * obj1 = 0 ;
30183 char * kwnames[] = {
30184 (char *) "self",(char *) "name", NULL
30185 };
30186
30187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30189 if (!SWIG_IsOK(res1)) {
30190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30191 }
30192 arg1 = reinterpret_cast< wxWindow * >(argp1);
30193 {
30194 arg2 = wxString_in_helper(obj1);
30195 if (arg2 == NULL) SWIG_fail;
30196 temp2 = true;
30197 }
30198 {
30199 PyThreadState* __tstate = wxPyBeginAllowThreads();
30200 (arg1)->SetName((wxString const &)*arg2);
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 resultobj = SWIG_Py_Void();
30205 {
30206 if (temp2)
30207 delete arg2;
30208 }
30209 return resultobj;
30210 fail:
30211 {
30212 if (temp2)
30213 delete arg2;
30214 }
30215 return NULL;
30216 }
30217
30218
30219 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30220 PyObject *resultobj = 0;
30221 wxWindow *arg1 = (wxWindow *) 0 ;
30222 wxString result;
30223 void *argp1 = 0 ;
30224 int res1 = 0 ;
30225 PyObject *swig_obj[1] ;
30226
30227 if (!args) SWIG_fail;
30228 swig_obj[0] = args;
30229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30230 if (!SWIG_IsOK(res1)) {
30231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30232 }
30233 arg1 = reinterpret_cast< wxWindow * >(argp1);
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 result = ((wxWindow const *)arg1)->GetName();
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 {
30241 #if wxUSE_UNICODE
30242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30243 #else
30244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30245 #endif
30246 }
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj = 0;
30255 wxWindow *arg1 = (wxWindow *) 0 ;
30256 wxWindowVariant arg2 ;
30257 void *argp1 = 0 ;
30258 int res1 = 0 ;
30259 int val2 ;
30260 int ecode2 = 0 ;
30261 PyObject * obj0 = 0 ;
30262 PyObject * obj1 = 0 ;
30263 char * kwnames[] = {
30264 (char *) "self",(char *) "variant", NULL
30265 };
30266
30267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30269 if (!SWIG_IsOK(res1)) {
30270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30271 }
30272 arg1 = reinterpret_cast< wxWindow * >(argp1);
30273 ecode2 = SWIG_AsVal_int(obj1, &val2);
30274 if (!SWIG_IsOK(ecode2)) {
30275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30276 }
30277 arg2 = static_cast< wxWindowVariant >(val2);
30278 {
30279 PyThreadState* __tstate = wxPyBeginAllowThreads();
30280 (arg1)->SetWindowVariant(arg2);
30281 wxPyEndAllowThreads(__tstate);
30282 if (PyErr_Occurred()) SWIG_fail;
30283 }
30284 resultobj = SWIG_Py_Void();
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30292 PyObject *resultobj = 0;
30293 wxWindow *arg1 = (wxWindow *) 0 ;
30294 wxWindowVariant result;
30295 void *argp1 = 0 ;
30296 int res1 = 0 ;
30297 PyObject *swig_obj[1] ;
30298
30299 if (!args) SWIG_fail;
30300 swig_obj[0] = args;
30301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30302 if (!SWIG_IsOK(res1)) {
30303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30304 }
30305 arg1 = reinterpret_cast< wxWindow * >(argp1);
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30309 wxPyEndAllowThreads(__tstate);
30310 if (PyErr_Occurred()) SWIG_fail;
30311 }
30312 resultobj = SWIG_From_int(static_cast< int >(result));
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30320 PyObject *resultobj = 0;
30321 wxWindow *arg1 = (wxWindow *) 0 ;
30322 int arg2 ;
30323 void *argp1 = 0 ;
30324 int res1 = 0 ;
30325 int val2 ;
30326 int ecode2 = 0 ;
30327 PyObject * obj0 = 0 ;
30328 PyObject * obj1 = 0 ;
30329 char * kwnames[] = {
30330 (char *) "self",(char *) "winid", NULL
30331 };
30332
30333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30335 if (!SWIG_IsOK(res1)) {
30336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30337 }
30338 arg1 = reinterpret_cast< wxWindow * >(argp1);
30339 ecode2 = SWIG_AsVal_int(obj1, &val2);
30340 if (!SWIG_IsOK(ecode2)) {
30341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30342 }
30343 arg2 = static_cast< int >(val2);
30344 {
30345 PyThreadState* __tstate = wxPyBeginAllowThreads();
30346 (arg1)->SetId(arg2);
30347 wxPyEndAllowThreads(__tstate);
30348 if (PyErr_Occurred()) SWIG_fail;
30349 }
30350 resultobj = SWIG_Py_Void();
30351 return resultobj;
30352 fail:
30353 return NULL;
30354 }
30355
30356
30357 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30358 PyObject *resultobj = 0;
30359 wxWindow *arg1 = (wxWindow *) 0 ;
30360 int result;
30361 void *argp1 = 0 ;
30362 int res1 = 0 ;
30363 PyObject *swig_obj[1] ;
30364
30365 if (!args) SWIG_fail;
30366 swig_obj[0] = args;
30367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30368 if (!SWIG_IsOK(res1)) {
30369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30370 }
30371 arg1 = reinterpret_cast< wxWindow * >(argp1);
30372 {
30373 PyThreadState* __tstate = wxPyBeginAllowThreads();
30374 result = (int)((wxWindow const *)arg1)->GetId();
30375 wxPyEndAllowThreads(__tstate);
30376 if (PyErr_Occurred()) SWIG_fail;
30377 }
30378 resultobj = SWIG_From_int(static_cast< int >(result));
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30386 PyObject *resultobj = 0;
30387 int result;
30388
30389 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 result = (int)wxWindow::NewControlId();
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 resultobj = SWIG_From_int(static_cast< int >(result));
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj = 0;
30405 int arg1 ;
30406 int result;
30407 int val1 ;
30408 int ecode1 = 0 ;
30409 PyObject * obj0 = 0 ;
30410 char * kwnames[] = {
30411 (char *) "winid", NULL
30412 };
30413
30414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30415 ecode1 = SWIG_AsVal_int(obj0, &val1);
30416 if (!SWIG_IsOK(ecode1)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30418 }
30419 arg1 = static_cast< int >(val1);
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 result = (int)wxWindow::NextControlId(arg1);
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 resultobj = SWIG_From_int(static_cast< int >(result));
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30434 PyObject *resultobj = 0;
30435 int arg1 ;
30436 int result;
30437 int val1 ;
30438 int ecode1 = 0 ;
30439 PyObject * obj0 = 0 ;
30440 char * kwnames[] = {
30441 (char *) "winid", NULL
30442 };
30443
30444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30445 ecode1 = SWIG_AsVal_int(obj0, &val1);
30446 if (!SWIG_IsOK(ecode1)) {
30447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30448 }
30449 arg1 = static_cast< int >(val1);
30450 {
30451 PyThreadState* __tstate = wxPyBeginAllowThreads();
30452 result = (int)wxWindow::PrevControlId(arg1);
30453 wxPyEndAllowThreads(__tstate);
30454 if (PyErr_Occurred()) SWIG_fail;
30455 }
30456 resultobj = SWIG_From_int(static_cast< int >(result));
30457 return resultobj;
30458 fail:
30459 return NULL;
30460 }
30461
30462
30463 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30464 PyObject *resultobj = 0;
30465 wxWindow *arg1 = (wxWindow *) 0 ;
30466 wxSize *arg2 = 0 ;
30467 void *argp1 = 0 ;
30468 int res1 = 0 ;
30469 wxSize temp2 ;
30470 PyObject * obj0 = 0 ;
30471 PyObject * obj1 = 0 ;
30472 char * kwnames[] = {
30473 (char *) "self",(char *) "size", NULL
30474 };
30475
30476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30478 if (!SWIG_IsOK(res1)) {
30479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30480 }
30481 arg1 = reinterpret_cast< wxWindow * >(argp1);
30482 {
30483 arg2 = &temp2;
30484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30485 }
30486 {
30487 PyThreadState* __tstate = wxPyBeginAllowThreads();
30488 (arg1)->SetSize((wxSize const &)*arg2);
30489 wxPyEndAllowThreads(__tstate);
30490 if (PyErr_Occurred()) SWIG_fail;
30491 }
30492 resultobj = SWIG_Py_Void();
30493 return resultobj;
30494 fail:
30495 return NULL;
30496 }
30497
30498
30499 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30500 PyObject *resultobj = 0;
30501 wxWindow *arg1 = (wxWindow *) 0 ;
30502 int arg2 ;
30503 int arg3 ;
30504 int arg4 ;
30505 int arg5 ;
30506 int arg6 = (int) wxSIZE_AUTO ;
30507 void *argp1 = 0 ;
30508 int res1 = 0 ;
30509 int val2 ;
30510 int ecode2 = 0 ;
30511 int val3 ;
30512 int ecode3 = 0 ;
30513 int val4 ;
30514 int ecode4 = 0 ;
30515 int val5 ;
30516 int ecode5 = 0 ;
30517 int val6 ;
30518 int ecode6 = 0 ;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 PyObject * obj2 = 0 ;
30522 PyObject * obj3 = 0 ;
30523 PyObject * obj4 = 0 ;
30524 PyObject * obj5 = 0 ;
30525 char * kwnames[] = {
30526 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30527 };
30528
30529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30531 if (!SWIG_IsOK(res1)) {
30532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30533 }
30534 arg1 = reinterpret_cast< wxWindow * >(argp1);
30535 ecode2 = SWIG_AsVal_int(obj1, &val2);
30536 if (!SWIG_IsOK(ecode2)) {
30537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30538 }
30539 arg2 = static_cast< int >(val2);
30540 ecode3 = SWIG_AsVal_int(obj2, &val3);
30541 if (!SWIG_IsOK(ecode3)) {
30542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30543 }
30544 arg3 = static_cast< int >(val3);
30545 ecode4 = SWIG_AsVal_int(obj3, &val4);
30546 if (!SWIG_IsOK(ecode4)) {
30547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30548 }
30549 arg4 = static_cast< int >(val4);
30550 ecode5 = SWIG_AsVal_int(obj4, &val5);
30551 if (!SWIG_IsOK(ecode5)) {
30552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30553 }
30554 arg5 = static_cast< int >(val5);
30555 if (obj5) {
30556 ecode6 = SWIG_AsVal_int(obj5, &val6);
30557 if (!SWIG_IsOK(ecode6)) {
30558 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30559 }
30560 arg6 = static_cast< int >(val6);
30561 }
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 resultobj = SWIG_Py_Void();
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj = 0;
30577 wxWindow *arg1 = (wxWindow *) 0 ;
30578 wxRect *arg2 = 0 ;
30579 int arg3 = (int) wxSIZE_AUTO ;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 wxRect temp2 ;
30583 int val3 ;
30584 int ecode3 = 0 ;
30585 PyObject * obj0 = 0 ;
30586 PyObject * obj1 = 0 ;
30587 PyObject * obj2 = 0 ;
30588 char * kwnames[] = {
30589 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30590 };
30591
30592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30596 }
30597 arg1 = reinterpret_cast< wxWindow * >(argp1);
30598 {
30599 arg2 = &temp2;
30600 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30601 }
30602 if (obj2) {
30603 ecode3 = SWIG_AsVal_int(obj2, &val3);
30604 if (!SWIG_IsOK(ecode3)) {
30605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30606 }
30607 arg3 = static_cast< int >(val3);
30608 }
30609 {
30610 PyThreadState* __tstate = wxPyBeginAllowThreads();
30611 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30612 wxPyEndAllowThreads(__tstate);
30613 if (PyErr_Occurred()) SWIG_fail;
30614 }
30615 resultobj = SWIG_Py_Void();
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30623 PyObject *resultobj = 0;
30624 wxWindow *arg1 = (wxWindow *) 0 ;
30625 int arg2 ;
30626 int arg3 ;
30627 void *argp1 = 0 ;
30628 int res1 = 0 ;
30629 int val2 ;
30630 int ecode2 = 0 ;
30631 int val3 ;
30632 int ecode3 = 0 ;
30633 PyObject * obj0 = 0 ;
30634 PyObject * obj1 = 0 ;
30635 PyObject * obj2 = 0 ;
30636 char * kwnames[] = {
30637 (char *) "self",(char *) "width",(char *) "height", NULL
30638 };
30639
30640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30642 if (!SWIG_IsOK(res1)) {
30643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30644 }
30645 arg1 = reinterpret_cast< wxWindow * >(argp1);
30646 ecode2 = SWIG_AsVal_int(obj1, &val2);
30647 if (!SWIG_IsOK(ecode2)) {
30648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30649 }
30650 arg2 = static_cast< int >(val2);
30651 ecode3 = SWIG_AsVal_int(obj2, &val3);
30652 if (!SWIG_IsOK(ecode3)) {
30653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30654 }
30655 arg3 = static_cast< int >(val3);
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 (arg1)->SetSize(arg2,arg3);
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 resultobj = SWIG_Py_Void();
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30670 PyObject *resultobj = 0;
30671 wxWindow *arg1 = (wxWindow *) 0 ;
30672 wxPoint *arg2 = 0 ;
30673 int arg3 = (int) wxSIZE_USE_EXISTING ;
30674 void *argp1 = 0 ;
30675 int res1 = 0 ;
30676 wxPoint temp2 ;
30677 int val3 ;
30678 int ecode3 = 0 ;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 PyObject * obj2 = 0 ;
30682 char * kwnames[] = {
30683 (char *) "self",(char *) "pt",(char *) "flags", NULL
30684 };
30685
30686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 arg2 = &temp2;
30694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30695 }
30696 if (obj2) {
30697 ecode3 = SWIG_AsVal_int(obj2, &val3);
30698 if (!SWIG_IsOK(ecode3)) {
30699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30700 }
30701 arg3 = static_cast< int >(val3);
30702 }
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 (arg1)->Move((wxPoint const &)*arg2,arg3);
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_Py_Void();
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = 0;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 int arg2 ;
30720 int arg3 ;
30721 int arg4 = (int) wxSIZE_USE_EXISTING ;
30722 void *argp1 = 0 ;
30723 int res1 = 0 ;
30724 int val2 ;
30725 int ecode2 = 0 ;
30726 int val3 ;
30727 int ecode3 = 0 ;
30728 int val4 ;
30729 int ecode4 = 0 ;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732 PyObject * obj2 = 0 ;
30733 PyObject * obj3 = 0 ;
30734 char * kwnames[] = {
30735 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30736 };
30737
30738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30740 if (!SWIG_IsOK(res1)) {
30741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30742 }
30743 arg1 = reinterpret_cast< wxWindow * >(argp1);
30744 ecode2 = SWIG_AsVal_int(obj1, &val2);
30745 if (!SWIG_IsOK(ecode2)) {
30746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30747 }
30748 arg2 = static_cast< int >(val2);
30749 ecode3 = SWIG_AsVal_int(obj2, &val3);
30750 if (!SWIG_IsOK(ecode3)) {
30751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30752 }
30753 arg3 = static_cast< int >(val3);
30754 if (obj3) {
30755 ecode4 = SWIG_AsVal_int(obj3, &val4);
30756 if (!SWIG_IsOK(ecode4)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30758 }
30759 arg4 = static_cast< int >(val4);
30760 }
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 (arg1)->Move(arg2,arg3,arg4);
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_Py_Void();
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30775 PyObject *resultobj = 0;
30776 wxWindow *arg1 = (wxWindow *) 0 ;
30777 wxSize const &arg2_defvalue = wxDefaultSize ;
30778 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30779 void *argp1 = 0 ;
30780 int res1 = 0 ;
30781 wxSize temp2 ;
30782 PyObject * obj0 = 0 ;
30783 PyObject * obj1 = 0 ;
30784 char * kwnames[] = {
30785 (char *) "self",(char *) "size", NULL
30786 };
30787
30788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30790 if (!SWIG_IsOK(res1)) {
30791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30792 }
30793 arg1 = reinterpret_cast< wxWindow * >(argp1);
30794 if (obj1) {
30795 {
30796 arg2 = &temp2;
30797 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30798 }
30799 }
30800 {
30801 PyThreadState* __tstate = wxPyBeginAllowThreads();
30802 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30803 wxPyEndAllowThreads(__tstate);
30804 if (PyErr_Occurred()) SWIG_fail;
30805 }
30806 resultobj = SWIG_Py_Void();
30807 return resultobj;
30808 fail:
30809 return NULL;
30810 }
30811
30812
30813 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30814 PyObject *resultobj = 0;
30815 wxWindow *arg1 = (wxWindow *) 0 ;
30816 void *argp1 = 0 ;
30817 int res1 = 0 ;
30818 PyObject *swig_obj[1] ;
30819
30820 if (!args) SWIG_fail;
30821 swig_obj[0] = args;
30822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30825 }
30826 arg1 = reinterpret_cast< wxWindow * >(argp1);
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 (arg1)->Raise();
30830 wxPyEndAllowThreads(__tstate);
30831 if (PyErr_Occurred()) SWIG_fail;
30832 }
30833 resultobj = SWIG_Py_Void();
30834 return resultobj;
30835 fail:
30836 return NULL;
30837 }
30838
30839
30840 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30841 PyObject *resultobj = 0;
30842 wxWindow *arg1 = (wxWindow *) 0 ;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30852 }
30853 arg1 = reinterpret_cast< wxWindow * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 (arg1)->Lower();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 resultobj = SWIG_Py_Void();
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj = 0;
30869 wxWindow *arg1 = (wxWindow *) 0 ;
30870 wxSize *arg2 = 0 ;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 wxSize temp2 ;
30874 PyObject * obj0 = 0 ;
30875 PyObject * obj1 = 0 ;
30876 char * kwnames[] = {
30877 (char *) "self",(char *) "size", NULL
30878 };
30879
30880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30884 }
30885 arg1 = reinterpret_cast< wxWindow * >(argp1);
30886 {
30887 arg2 = &temp2;
30888 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30889 }
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 (arg1)->SetClientSize((wxSize const &)*arg2);
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 resultobj = SWIG_Py_Void();
30897 return resultobj;
30898 fail:
30899 return NULL;
30900 }
30901
30902
30903 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30904 PyObject *resultobj = 0;
30905 wxWindow *arg1 = (wxWindow *) 0 ;
30906 int arg2 ;
30907 int arg3 ;
30908 void *argp1 = 0 ;
30909 int res1 = 0 ;
30910 int val2 ;
30911 int ecode2 = 0 ;
30912 int val3 ;
30913 int ecode3 = 0 ;
30914 PyObject * obj0 = 0 ;
30915 PyObject * obj1 = 0 ;
30916 PyObject * obj2 = 0 ;
30917 char * kwnames[] = {
30918 (char *) "self",(char *) "width",(char *) "height", NULL
30919 };
30920
30921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30923 if (!SWIG_IsOK(res1)) {
30924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30925 }
30926 arg1 = reinterpret_cast< wxWindow * >(argp1);
30927 ecode2 = SWIG_AsVal_int(obj1, &val2);
30928 if (!SWIG_IsOK(ecode2)) {
30929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30930 }
30931 arg2 = static_cast< int >(val2);
30932 ecode3 = SWIG_AsVal_int(obj2, &val3);
30933 if (!SWIG_IsOK(ecode3)) {
30934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30935 }
30936 arg3 = static_cast< int >(val3);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 (arg1)->SetClientSize(arg2,arg3);
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 resultobj = SWIG_Py_Void();
30944 return resultobj;
30945 fail:
30946 return NULL;
30947 }
30948
30949
30950 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30951 PyObject *resultobj = 0;
30952 wxWindow *arg1 = (wxWindow *) 0 ;
30953 wxRect *arg2 = 0 ;
30954 void *argp1 = 0 ;
30955 int res1 = 0 ;
30956 wxRect temp2 ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 char * kwnames[] = {
30960 (char *) "self",(char *) "rect", NULL
30961 };
30962
30963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30967 }
30968 arg1 = reinterpret_cast< wxWindow * >(argp1);
30969 {
30970 arg2 = &temp2;
30971 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30972 }
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 (arg1)->SetClientSize((wxRect const &)*arg2);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_Py_Void();
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 wxWindow *arg1 = (wxWindow *) 0 ;
30989 wxPoint result;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 PyObject *swig_obj[1] ;
30993
30994 if (!args) SWIG_fail;
30995 swig_obj[0] = args;
30996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30999 }
31000 arg1 = reinterpret_cast< wxWindow * >(argp1);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = ((wxWindow const *)arg1)->GetPosition();
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 int *arg2 = (int *) 0 ;
31018 int *arg3 = (int *) 0 ;
31019 void *argp1 = 0 ;
31020 int res1 = 0 ;
31021 int temp2 ;
31022 int res2 = SWIG_TMPOBJ ;
31023 int temp3 ;
31024 int res3 = SWIG_TMPOBJ ;
31025 PyObject *swig_obj[1] ;
31026
31027 arg2 = &temp2;
31028 arg3 = &temp3;
31029 if (!args) SWIG_fail;
31030 swig_obj[0] = args;
31031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31032 if (!SWIG_IsOK(res1)) {
31033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31034 }
31035 arg1 = reinterpret_cast< wxWindow * >(argp1);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_Py_Void();
31043 if (SWIG_IsTmpObj(res2)) {
31044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31045 } else {
31046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31048 }
31049 if (SWIG_IsTmpObj(res3)) {
31050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31051 } else {
31052 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31054 }
31055 return resultobj;
31056 fail:
31057 return NULL;
31058 }
31059
31060
31061 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31062 PyObject *resultobj = 0;
31063 wxWindow *arg1 = (wxWindow *) 0 ;
31064 wxPoint result;
31065 void *argp1 = 0 ;
31066 int res1 = 0 ;
31067 PyObject *swig_obj[1] ;
31068
31069 if (!args) SWIG_fail;
31070 swig_obj[0] = args;
31071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31072 if (!SWIG_IsOK(res1)) {
31073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31074 }
31075 arg1 = reinterpret_cast< wxWindow * >(argp1);
31076 {
31077 PyThreadState* __tstate = wxPyBeginAllowThreads();
31078 result = ((wxWindow const *)arg1)->GetScreenPosition();
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 wxWindow *arg1 = (wxWindow *) 0 ;
31092 int *arg2 = (int *) 0 ;
31093 int *arg3 = (int *) 0 ;
31094 void *argp1 = 0 ;
31095 int res1 = 0 ;
31096 int temp2 ;
31097 int res2 = SWIG_TMPOBJ ;
31098 int temp3 ;
31099 int res3 = SWIG_TMPOBJ ;
31100 PyObject *swig_obj[1] ;
31101
31102 arg2 = &temp2;
31103 arg3 = &temp3;
31104 if (!args) SWIG_fail;
31105 swig_obj[0] = args;
31106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31107 if (!SWIG_IsOK(res1)) {
31108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31109 }
31110 arg1 = reinterpret_cast< wxWindow * >(argp1);
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 resultobj = SWIG_Py_Void();
31118 if (SWIG_IsTmpObj(res2)) {
31119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31120 } else {
31121 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31123 }
31124 if (SWIG_IsTmpObj(res3)) {
31125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31126 } else {
31127 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31129 }
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxWindow *arg1 = (wxWindow *) 0 ;
31139 wxRect result;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31149 }
31150 arg1 = reinterpret_cast< wxWindow * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = ((wxWindow const *)arg1)->GetScreenRect();
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31165 PyObject *resultobj = 0;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 wxSize result;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 PyObject *swig_obj[1] ;
31171
31172 if (!args) SWIG_fail;
31173 swig_obj[0] = args;
31174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31177 }
31178 arg1 = reinterpret_cast< wxWindow * >(argp1);
31179 {
31180 PyThreadState* __tstate = wxPyBeginAllowThreads();
31181 result = ((wxWindow const *)arg1)->GetSize();
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31193 PyObject *resultobj = 0;
31194 wxWindow *arg1 = (wxWindow *) 0 ;
31195 int *arg2 = (int *) 0 ;
31196 int *arg3 = (int *) 0 ;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 int temp2 ;
31200 int res2 = SWIG_TMPOBJ ;
31201 int temp3 ;
31202 int res3 = SWIG_TMPOBJ ;
31203 PyObject *swig_obj[1] ;
31204
31205 arg2 = &temp2;
31206 arg3 = &temp3;
31207 if (!args) SWIG_fail;
31208 swig_obj[0] = args;
31209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31210 if (!SWIG_IsOK(res1)) {
31211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31212 }
31213 arg1 = reinterpret_cast< wxWindow * >(argp1);
31214 {
31215 PyThreadState* __tstate = wxPyBeginAllowThreads();
31216 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31217 wxPyEndAllowThreads(__tstate);
31218 if (PyErr_Occurred()) SWIG_fail;
31219 }
31220 resultobj = SWIG_Py_Void();
31221 if (SWIG_IsTmpObj(res2)) {
31222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31223 } else {
31224 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31226 }
31227 if (SWIG_IsTmpObj(res3)) {
31228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31229 } else {
31230 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31232 }
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31240 PyObject *resultobj = 0;
31241 wxWindow *arg1 = (wxWindow *) 0 ;
31242 wxRect result;
31243 void *argp1 = 0 ;
31244 int res1 = 0 ;
31245 PyObject *swig_obj[1] ;
31246
31247 if (!args) SWIG_fail;
31248 swig_obj[0] = args;
31249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31250 if (!SWIG_IsOK(res1)) {
31251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31252 }
31253 arg1 = reinterpret_cast< wxWindow * >(argp1);
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 result = ((wxWindow const *)arg1)->GetRect();
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31268 PyObject *resultobj = 0;
31269 wxWindow *arg1 = (wxWindow *) 0 ;
31270 wxSize result;
31271 void *argp1 = 0 ;
31272 int res1 = 0 ;
31273 PyObject *swig_obj[1] ;
31274
31275 if (!args) SWIG_fail;
31276 swig_obj[0] = args;
31277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31278 if (!SWIG_IsOK(res1)) {
31279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31280 }
31281 arg1 = reinterpret_cast< wxWindow * >(argp1);
31282 {
31283 PyThreadState* __tstate = wxPyBeginAllowThreads();
31284 result = ((wxWindow const *)arg1)->GetClientSize();
31285 wxPyEndAllowThreads(__tstate);
31286 if (PyErr_Occurred()) SWIG_fail;
31287 }
31288 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31289 return resultobj;
31290 fail:
31291 return NULL;
31292 }
31293
31294
31295 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31296 PyObject *resultobj = 0;
31297 wxWindow *arg1 = (wxWindow *) 0 ;
31298 int *arg2 = (int *) 0 ;
31299 int *arg3 = (int *) 0 ;
31300 void *argp1 = 0 ;
31301 int res1 = 0 ;
31302 int temp2 ;
31303 int res2 = SWIG_TMPOBJ ;
31304 int temp3 ;
31305 int res3 = SWIG_TMPOBJ ;
31306 PyObject *swig_obj[1] ;
31307
31308 arg2 = &temp2;
31309 arg3 = &temp3;
31310 if (!args) SWIG_fail;
31311 swig_obj[0] = args;
31312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31313 if (!SWIG_IsOK(res1)) {
31314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31315 }
31316 arg1 = reinterpret_cast< wxWindow * >(argp1);
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 resultobj = SWIG_Py_Void();
31324 if (SWIG_IsTmpObj(res2)) {
31325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31326 } else {
31327 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31329 }
31330 if (SWIG_IsTmpObj(res3)) {
31331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31332 } else {
31333 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31335 }
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31343 PyObject *resultobj = 0;
31344 wxWindow *arg1 = (wxWindow *) 0 ;
31345 wxPoint result;
31346 void *argp1 = 0 ;
31347 int res1 = 0 ;
31348 PyObject *swig_obj[1] ;
31349
31350 if (!args) SWIG_fail;
31351 swig_obj[0] = args;
31352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31353 if (!SWIG_IsOK(res1)) {
31354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31355 }
31356 arg1 = reinterpret_cast< wxWindow * >(argp1);
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31360 wxPyEndAllowThreads(__tstate);
31361 if (PyErr_Occurred()) SWIG_fail;
31362 }
31363 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31364 return resultobj;
31365 fail:
31366 return NULL;
31367 }
31368
31369
31370 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31371 PyObject *resultobj = 0;
31372 wxWindow *arg1 = (wxWindow *) 0 ;
31373 wxRect result;
31374 void *argp1 = 0 ;
31375 int res1 = 0 ;
31376 PyObject *swig_obj[1] ;
31377
31378 if (!args) SWIG_fail;
31379 swig_obj[0] = args;
31380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31381 if (!SWIG_IsOK(res1)) {
31382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31383 }
31384 arg1 = reinterpret_cast< wxWindow * >(argp1);
31385 {
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 result = ((wxWindow const *)arg1)->GetClientRect();
31388 wxPyEndAllowThreads(__tstate);
31389 if (PyErr_Occurred()) SWIG_fail;
31390 }
31391 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31399 PyObject *resultobj = 0;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 wxSize result;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 PyObject *swig_obj[1] ;
31405
31406 if (!args) SWIG_fail;
31407 swig_obj[0] = args;
31408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31409 if (!SWIG_IsOK(res1)) {
31410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31411 }
31412 arg1 = reinterpret_cast< wxWindow * >(argp1);
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 result = ((wxWindow const *)arg1)->GetBestSize();
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31427 PyObject *resultobj = 0;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 int *arg2 = (int *) 0 ;
31430 int *arg3 = (int *) 0 ;
31431 void *argp1 = 0 ;
31432 int res1 = 0 ;
31433 int temp2 ;
31434 int res2 = SWIG_TMPOBJ ;
31435 int temp3 ;
31436 int res3 = SWIG_TMPOBJ ;
31437 PyObject *swig_obj[1] ;
31438
31439 arg2 = &temp2;
31440 arg3 = &temp3;
31441 if (!args) SWIG_fail;
31442 swig_obj[0] = args;
31443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31444 if (!SWIG_IsOK(res1)) {
31445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31446 }
31447 arg1 = reinterpret_cast< wxWindow * >(argp1);
31448 {
31449 PyThreadState* __tstate = wxPyBeginAllowThreads();
31450 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31451 wxPyEndAllowThreads(__tstate);
31452 if (PyErr_Occurred()) SWIG_fail;
31453 }
31454 resultobj = SWIG_Py_Void();
31455 if (SWIG_IsTmpObj(res2)) {
31456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31457 } else {
31458 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31459 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31460 }
31461 if (SWIG_IsTmpObj(res3)) {
31462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31463 } else {
31464 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31466 }
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *resultobj = 0;
31475 wxWindow *arg1 = (wxWindow *) 0 ;
31476 void *argp1 = 0 ;
31477 int res1 = 0 ;
31478 PyObject *swig_obj[1] ;
31479
31480 if (!args) SWIG_fail;
31481 swig_obj[0] = args;
31482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31485 }
31486 arg1 = reinterpret_cast< wxWindow * >(argp1);
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 (arg1)->InvalidateBestSize();
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 resultobj = SWIG_Py_Void();
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31501 PyObject *resultobj = 0;
31502 wxWindow *arg1 = (wxWindow *) 0 ;
31503 wxSize *arg2 = 0 ;
31504 void *argp1 = 0 ;
31505 int res1 = 0 ;
31506 wxSize temp2 ;
31507 PyObject * obj0 = 0 ;
31508 PyObject * obj1 = 0 ;
31509 char * kwnames[] = {
31510 (char *) "self",(char *) "size", NULL
31511 };
31512
31513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31515 if (!SWIG_IsOK(res1)) {
31516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31517 }
31518 arg1 = reinterpret_cast< wxWindow * >(argp1);
31519 {
31520 arg2 = &temp2;
31521 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31522 }
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_Py_Void();
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31537 PyObject *resultobj = 0;
31538 wxWindow *arg1 = (wxWindow *) 0 ;
31539 wxSize result;
31540 void *argp1 = 0 ;
31541 int res1 = 0 ;
31542 PyObject *swig_obj[1] ;
31543
31544 if (!args) SWIG_fail;
31545 swig_obj[0] = args;
31546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31547 if (!SWIG_IsOK(res1)) {
31548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31549 }
31550 arg1 = reinterpret_cast< wxWindow * >(argp1);
31551 {
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31554 wxPyEndAllowThreads(__tstate);
31555 if (PyErr_Occurred()) SWIG_fail;
31556 }
31557 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31565 PyObject *resultobj = 0;
31566 wxWindow *arg1 = (wxWindow *) 0 ;
31567 wxSize result;
31568 void *argp1 = 0 ;
31569 int res1 = 0 ;
31570 PyObject *swig_obj[1] ;
31571
31572 if (!args) SWIG_fail;
31573 swig_obj[0] = args;
31574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31575 if (!SWIG_IsOK(res1)) {
31576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31577 }
31578 arg1 = reinterpret_cast< wxWindow * >(argp1);
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj = 0;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 int arg2 = (int) wxBOTH ;
31596 void *argp1 = 0 ;
31597 int res1 = 0 ;
31598 int val2 ;
31599 int ecode2 = 0 ;
31600 PyObject * obj0 = 0 ;
31601 PyObject * obj1 = 0 ;
31602 char * kwnames[] = {
31603 (char *) "self",(char *) "direction", NULL
31604 };
31605
31606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31608 if (!SWIG_IsOK(res1)) {
31609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31610 }
31611 arg1 = reinterpret_cast< wxWindow * >(argp1);
31612 if (obj1) {
31613 ecode2 = SWIG_AsVal_int(obj1, &val2);
31614 if (!SWIG_IsOK(ecode2)) {
31615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31616 }
31617 arg2 = static_cast< int >(val2);
31618 }
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 (arg1)->Center(arg2);
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_Py_Void();
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31633 PyObject *resultobj = 0;
31634 wxWindow *arg1 = (wxWindow *) 0 ;
31635 int arg2 = (int) wxBOTH ;
31636 void *argp1 = 0 ;
31637 int res1 = 0 ;
31638 int val2 ;
31639 int ecode2 = 0 ;
31640 PyObject * obj0 = 0 ;
31641 PyObject * obj1 = 0 ;
31642 char * kwnames[] = {
31643 (char *) "self",(char *) "dir", NULL
31644 };
31645
31646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31648 if (!SWIG_IsOK(res1)) {
31649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31650 }
31651 arg1 = reinterpret_cast< wxWindow * >(argp1);
31652 if (obj1) {
31653 ecode2 = SWIG_AsVal_int(obj1, &val2);
31654 if (!SWIG_IsOK(ecode2)) {
31655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31656 }
31657 arg2 = static_cast< int >(val2);
31658 }
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 (arg1)->CenterOnParent(arg2);
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 resultobj = SWIG_Py_Void();
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31673 PyObject *resultobj = 0;
31674 wxWindow *arg1 = (wxWindow *) 0 ;
31675 void *argp1 = 0 ;
31676 int res1 = 0 ;
31677 PyObject *swig_obj[1] ;
31678
31679 if (!args) SWIG_fail;
31680 swig_obj[0] = args;
31681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31682 if (!SWIG_IsOK(res1)) {
31683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31684 }
31685 arg1 = reinterpret_cast< wxWindow * >(argp1);
31686 {
31687 PyThreadState* __tstate = wxPyBeginAllowThreads();
31688 (arg1)->Fit();
31689 wxPyEndAllowThreads(__tstate);
31690 if (PyErr_Occurred()) SWIG_fail;
31691 }
31692 resultobj = SWIG_Py_Void();
31693 return resultobj;
31694 fail:
31695 return NULL;
31696 }
31697
31698
31699 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31700 PyObject *resultobj = 0;
31701 wxWindow *arg1 = (wxWindow *) 0 ;
31702 void *argp1 = 0 ;
31703 int res1 = 0 ;
31704 PyObject *swig_obj[1] ;
31705
31706 if (!args) SWIG_fail;
31707 swig_obj[0] = args;
31708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31709 if (!SWIG_IsOK(res1)) {
31710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31711 }
31712 arg1 = reinterpret_cast< wxWindow * >(argp1);
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 (arg1)->FitInside();
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 resultobj = SWIG_Py_Void();
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31727 PyObject *resultobj = 0;
31728 wxWindow *arg1 = (wxWindow *) 0 ;
31729 int arg2 ;
31730 int arg3 ;
31731 int arg4 = (int) -1 ;
31732 int arg5 = (int) -1 ;
31733 int arg6 = (int) -1 ;
31734 int arg7 = (int) -1 ;
31735 void *argp1 = 0 ;
31736 int res1 = 0 ;
31737 int val2 ;
31738 int ecode2 = 0 ;
31739 int val3 ;
31740 int ecode3 = 0 ;
31741 int val4 ;
31742 int ecode4 = 0 ;
31743 int val5 ;
31744 int ecode5 = 0 ;
31745 int val6 ;
31746 int ecode6 = 0 ;
31747 int val7 ;
31748 int ecode7 = 0 ;
31749 PyObject * obj0 = 0 ;
31750 PyObject * obj1 = 0 ;
31751 PyObject * obj2 = 0 ;
31752 PyObject * obj3 = 0 ;
31753 PyObject * obj4 = 0 ;
31754 PyObject * obj5 = 0 ;
31755 PyObject * obj6 = 0 ;
31756 char * kwnames[] = {
31757 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31758 };
31759
31760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31762 if (!SWIG_IsOK(res1)) {
31763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31764 }
31765 arg1 = reinterpret_cast< wxWindow * >(argp1);
31766 ecode2 = SWIG_AsVal_int(obj1, &val2);
31767 if (!SWIG_IsOK(ecode2)) {
31768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31769 }
31770 arg2 = static_cast< int >(val2);
31771 ecode3 = SWIG_AsVal_int(obj2, &val3);
31772 if (!SWIG_IsOK(ecode3)) {
31773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31774 }
31775 arg3 = static_cast< int >(val3);
31776 if (obj3) {
31777 ecode4 = SWIG_AsVal_int(obj3, &val4);
31778 if (!SWIG_IsOK(ecode4)) {
31779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31780 }
31781 arg4 = static_cast< int >(val4);
31782 }
31783 if (obj4) {
31784 ecode5 = SWIG_AsVal_int(obj4, &val5);
31785 if (!SWIG_IsOK(ecode5)) {
31786 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31787 }
31788 arg5 = static_cast< int >(val5);
31789 }
31790 if (obj5) {
31791 ecode6 = SWIG_AsVal_int(obj5, &val6);
31792 if (!SWIG_IsOK(ecode6)) {
31793 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31794 }
31795 arg6 = static_cast< int >(val6);
31796 }
31797 if (obj6) {
31798 ecode7 = SWIG_AsVal_int(obj6, &val7);
31799 if (!SWIG_IsOK(ecode7)) {
31800 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31801 }
31802 arg7 = static_cast< int >(val7);
31803 }
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 resultobj = SWIG_Py_Void();
31811 return resultobj;
31812 fail:
31813 return NULL;
31814 }
31815
31816
31817 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31818 PyObject *resultobj = 0;
31819 wxWindow *arg1 = (wxWindow *) 0 ;
31820 wxSize *arg2 = 0 ;
31821 wxSize const &arg3_defvalue = wxDefaultSize ;
31822 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31823 wxSize const &arg4_defvalue = wxDefaultSize ;
31824 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 wxSize temp2 ;
31828 wxSize temp3 ;
31829 wxSize temp4 ;
31830 PyObject * obj0 = 0 ;
31831 PyObject * obj1 = 0 ;
31832 PyObject * obj2 = 0 ;
31833 PyObject * obj3 = 0 ;
31834 char * kwnames[] = {
31835 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31836 };
31837
31838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31840 if (!SWIG_IsOK(res1)) {
31841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31842 }
31843 arg1 = reinterpret_cast< wxWindow * >(argp1);
31844 {
31845 arg2 = &temp2;
31846 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31847 }
31848 if (obj2) {
31849 {
31850 arg3 = &temp3;
31851 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31852 }
31853 }
31854 if (obj3) {
31855 {
31856 arg4 = &temp4;
31857 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31858 }
31859 }
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 resultobj = SWIG_Py_Void();
31867 return resultobj;
31868 fail:
31869 return NULL;
31870 }
31871
31872
31873 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31874 PyObject *resultobj = 0;
31875 wxWindow *arg1 = (wxWindow *) 0 ;
31876 int arg2 ;
31877 int arg3 ;
31878 int arg4 = (int) -1 ;
31879 int arg5 = (int) -1 ;
31880 void *argp1 = 0 ;
31881 int res1 = 0 ;
31882 int val2 ;
31883 int ecode2 = 0 ;
31884 int val3 ;
31885 int ecode3 = 0 ;
31886 int val4 ;
31887 int ecode4 = 0 ;
31888 int val5 ;
31889 int ecode5 = 0 ;
31890 PyObject * obj0 = 0 ;
31891 PyObject * obj1 = 0 ;
31892 PyObject * obj2 = 0 ;
31893 PyObject * obj3 = 0 ;
31894 PyObject * obj4 = 0 ;
31895 char * kwnames[] = {
31896 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31897 };
31898
31899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31903 }
31904 arg1 = reinterpret_cast< wxWindow * >(argp1);
31905 ecode2 = SWIG_AsVal_int(obj1, &val2);
31906 if (!SWIG_IsOK(ecode2)) {
31907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31908 }
31909 arg2 = static_cast< int >(val2);
31910 ecode3 = SWIG_AsVal_int(obj2, &val3);
31911 if (!SWIG_IsOK(ecode3)) {
31912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31913 }
31914 arg3 = static_cast< int >(val3);
31915 if (obj3) {
31916 ecode4 = SWIG_AsVal_int(obj3, &val4);
31917 if (!SWIG_IsOK(ecode4)) {
31918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31919 }
31920 arg4 = static_cast< int >(val4);
31921 }
31922 if (obj4) {
31923 ecode5 = SWIG_AsVal_int(obj4, &val5);
31924 if (!SWIG_IsOK(ecode5)) {
31925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31926 }
31927 arg5 = static_cast< int >(val5);
31928 }
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31932 wxPyEndAllowThreads(__tstate);
31933 if (PyErr_Occurred()) SWIG_fail;
31934 }
31935 resultobj = SWIG_Py_Void();
31936 return resultobj;
31937 fail:
31938 return NULL;
31939 }
31940
31941
31942 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31943 PyObject *resultobj = 0;
31944 wxWindow *arg1 = (wxWindow *) 0 ;
31945 wxSize *arg2 = 0 ;
31946 wxSize const &arg3_defvalue = wxDefaultSize ;
31947 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 wxSize temp2 ;
31951 wxSize temp3 ;
31952 PyObject * obj0 = 0 ;
31953 PyObject * obj1 = 0 ;
31954 PyObject * obj2 = 0 ;
31955 char * kwnames[] = {
31956 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31957 };
31958
31959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31961 if (!SWIG_IsOK(res1)) {
31962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31963 }
31964 arg1 = reinterpret_cast< wxWindow * >(argp1);
31965 {
31966 arg2 = &temp2;
31967 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31968 }
31969 if (obj2) {
31970 {
31971 arg3 = &temp3;
31972 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31973 }
31974 }
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31978 wxPyEndAllowThreads(__tstate);
31979 if (PyErr_Occurred()) SWIG_fail;
31980 }
31981 resultobj = SWIG_Py_Void();
31982 return resultobj;
31983 fail:
31984 return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31989 PyObject *resultobj = 0;
31990 wxWindow *arg1 = (wxWindow *) 0 ;
31991 wxSize result;
31992 void *argp1 = 0 ;
31993 int res1 = 0 ;
31994 PyObject *swig_obj[1] ;
31995
31996 if (!args) SWIG_fail;
31997 swig_obj[0] = args;
31998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31999 if (!SWIG_IsOK(res1)) {
32000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32001 }
32002 arg1 = reinterpret_cast< wxWindow * >(argp1);
32003 {
32004 PyThreadState* __tstate = wxPyBeginAllowThreads();
32005 result = ((wxWindow const *)arg1)->GetMaxSize();
32006 wxPyEndAllowThreads(__tstate);
32007 if (PyErr_Occurred()) SWIG_fail;
32008 }
32009 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32010 return resultobj;
32011 fail:
32012 return NULL;
32013 }
32014
32015
32016 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32017 PyObject *resultobj = 0;
32018 wxWindow *arg1 = (wxWindow *) 0 ;
32019 wxSize result;
32020 void *argp1 = 0 ;
32021 int res1 = 0 ;
32022 PyObject *swig_obj[1] ;
32023
32024 if (!args) SWIG_fail;
32025 swig_obj[0] = args;
32026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32027 if (!SWIG_IsOK(res1)) {
32028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32029 }
32030 arg1 = reinterpret_cast< wxWindow * >(argp1);
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 result = ((wxWindow const *)arg1)->GetMinSize();
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32038 return resultobj;
32039 fail:
32040 return NULL;
32041 }
32042
32043
32044 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32045 PyObject *resultobj = 0;
32046 wxWindow *arg1 = (wxWindow *) 0 ;
32047 wxSize *arg2 = 0 ;
32048 void *argp1 = 0 ;
32049 int res1 = 0 ;
32050 wxSize temp2 ;
32051 PyObject * obj0 = 0 ;
32052 PyObject * obj1 = 0 ;
32053 char * kwnames[] = {
32054 (char *) "self",(char *) "minSize", NULL
32055 };
32056
32057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32059 if (!SWIG_IsOK(res1)) {
32060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32061 }
32062 arg1 = reinterpret_cast< wxWindow * >(argp1);
32063 {
32064 arg2 = &temp2;
32065 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32066 }
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 (arg1)->SetMinSize((wxSize const &)*arg2);
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_Py_Void();
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32081 PyObject *resultobj = 0;
32082 wxWindow *arg1 = (wxWindow *) 0 ;
32083 wxSize *arg2 = 0 ;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 wxSize temp2 ;
32087 PyObject * obj0 = 0 ;
32088 PyObject * obj1 = 0 ;
32089 char * kwnames[] = {
32090 (char *) "self",(char *) "maxSize", NULL
32091 };
32092
32093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32097 }
32098 arg1 = reinterpret_cast< wxWindow * >(argp1);
32099 {
32100 arg2 = &temp2;
32101 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32102 }
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 (arg1)->SetMaxSize((wxSize const &)*arg2);
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_Py_Void();
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 wxWindow *arg1 = (wxWindow *) 0 ;
32119 int result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 PyObject *swig_obj[1] ;
32123
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32129 }
32130 arg1 = reinterpret_cast< wxWindow * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_From_int(static_cast< int >(result));
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 int result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 PyObject *swig_obj[1] ;
32151
32152 if (!args) SWIG_fail;
32153 swig_obj[0] = args;
32154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32157 }
32158 arg1 = reinterpret_cast< wxWindow * >(argp1);
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 resultobj = SWIG_From_int(static_cast< int >(result));
32166 return resultobj;
32167 fail:
32168 return NULL;
32169 }
32170
32171
32172 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32173 PyObject *resultobj = 0;
32174 wxWindow *arg1 = (wxWindow *) 0 ;
32175 int result;
32176 void *argp1 = 0 ;
32177 int res1 = 0 ;
32178 PyObject *swig_obj[1] ;
32179
32180 if (!args) SWIG_fail;
32181 swig_obj[0] = args;
32182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32183 if (!SWIG_IsOK(res1)) {
32184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32185 }
32186 arg1 = reinterpret_cast< wxWindow * >(argp1);
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 resultobj = SWIG_From_int(static_cast< int >(result));
32194 return resultobj;
32195 fail:
32196 return NULL;
32197 }
32198
32199
32200 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32201 PyObject *resultobj = 0;
32202 wxWindow *arg1 = (wxWindow *) 0 ;
32203 int result;
32204 void *argp1 = 0 ;
32205 int res1 = 0 ;
32206 PyObject *swig_obj[1] ;
32207
32208 if (!args) SWIG_fail;
32209 swig_obj[0] = args;
32210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32211 if (!SWIG_IsOK(res1)) {
32212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32213 }
32214 arg1 = reinterpret_cast< wxWindow * >(argp1);
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 resultobj = SWIG_From_int(static_cast< int >(result));
32222 return resultobj;
32223 fail:
32224 return NULL;
32225 }
32226
32227
32228 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32229 PyObject *resultobj = 0;
32230 wxWindow *arg1 = (wxWindow *) 0 ;
32231 wxSize *arg2 = 0 ;
32232 void *argp1 = 0 ;
32233 int res1 = 0 ;
32234 wxSize temp2 ;
32235 PyObject * obj0 = 0 ;
32236 PyObject * obj1 = 0 ;
32237 char * kwnames[] = {
32238 (char *) "self",(char *) "size", NULL
32239 };
32240
32241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32243 if (!SWIG_IsOK(res1)) {
32244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32245 }
32246 arg1 = reinterpret_cast< wxWindow * >(argp1);
32247 {
32248 arg2 = &temp2;
32249 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32250 }
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 resultobj = SWIG_Py_Void();
32258 return resultobj;
32259 fail:
32260 return NULL;
32261 }
32262
32263
32264 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32265 PyObject *resultobj = 0;
32266 wxWindow *arg1 = (wxWindow *) 0 ;
32267 int arg2 ;
32268 int arg3 ;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 int val2 ;
32272 int ecode2 = 0 ;
32273 int val3 ;
32274 int ecode3 = 0 ;
32275 PyObject * obj0 = 0 ;
32276 PyObject * obj1 = 0 ;
32277 PyObject * obj2 = 0 ;
32278 char * kwnames[] = {
32279 (char *) "self",(char *) "w",(char *) "h", NULL
32280 };
32281
32282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32284 if (!SWIG_IsOK(res1)) {
32285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32286 }
32287 arg1 = reinterpret_cast< wxWindow * >(argp1);
32288 ecode2 = SWIG_AsVal_int(obj1, &val2);
32289 if (!SWIG_IsOK(ecode2)) {
32290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32291 }
32292 arg2 = static_cast< int >(val2);
32293 ecode3 = SWIG_AsVal_int(obj2, &val3);
32294 if (!SWIG_IsOK(ecode3)) {
32295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32296 }
32297 arg3 = static_cast< int >(val3);
32298 {
32299 PyThreadState* __tstate = wxPyBeginAllowThreads();
32300 (arg1)->SetVirtualSize(arg2,arg3);
32301 wxPyEndAllowThreads(__tstate);
32302 if (PyErr_Occurred()) SWIG_fail;
32303 }
32304 resultobj = SWIG_Py_Void();
32305 return resultobj;
32306 fail:
32307 return NULL;
32308 }
32309
32310
32311 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32312 PyObject *resultobj = 0;
32313 wxWindow *arg1 = (wxWindow *) 0 ;
32314 wxSize result;
32315 void *argp1 = 0 ;
32316 int res1 = 0 ;
32317 PyObject *swig_obj[1] ;
32318
32319 if (!args) SWIG_fail;
32320 swig_obj[0] = args;
32321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32322 if (!SWIG_IsOK(res1)) {
32323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32324 }
32325 arg1 = reinterpret_cast< wxWindow * >(argp1);
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 result = ((wxWindow const *)arg1)->GetVirtualSize();
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32333 return resultobj;
32334 fail:
32335 return NULL;
32336 }
32337
32338
32339 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32340 PyObject *resultobj = 0;
32341 wxWindow *arg1 = (wxWindow *) 0 ;
32342 int *arg2 = (int *) 0 ;
32343 int *arg3 = (int *) 0 ;
32344 void *argp1 = 0 ;
32345 int res1 = 0 ;
32346 int temp2 ;
32347 int res2 = SWIG_TMPOBJ ;
32348 int temp3 ;
32349 int res3 = SWIG_TMPOBJ ;
32350 PyObject *swig_obj[1] ;
32351
32352 arg2 = &temp2;
32353 arg3 = &temp3;
32354 if (!args) SWIG_fail;
32355 swig_obj[0] = args;
32356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32357 if (!SWIG_IsOK(res1)) {
32358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32359 }
32360 arg1 = reinterpret_cast< wxWindow * >(argp1);
32361 {
32362 PyThreadState* __tstate = wxPyBeginAllowThreads();
32363 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32364 wxPyEndAllowThreads(__tstate);
32365 if (PyErr_Occurred()) SWIG_fail;
32366 }
32367 resultobj = SWIG_Py_Void();
32368 if (SWIG_IsTmpObj(res2)) {
32369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32370 } else {
32371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32373 }
32374 if (SWIG_IsTmpObj(res3)) {
32375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32376 } else {
32377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32379 }
32380 return resultobj;
32381 fail:
32382 return NULL;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32387 PyObject *resultobj = 0;
32388 wxWindow *arg1 = (wxWindow *) 0 ;
32389 wxSize result;
32390 void *argp1 = 0 ;
32391 int res1 = 0 ;
32392 PyObject *swig_obj[1] ;
32393
32394 if (!args) SWIG_fail;
32395 swig_obj[0] = args;
32396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32397 if (!SWIG_IsOK(res1)) {
32398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32399 }
32400 arg1 = reinterpret_cast< wxWindow * >(argp1);
32401 {
32402 PyThreadState* __tstate = wxPyBeginAllowThreads();
32403 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32408 return resultobj;
32409 fail:
32410 return NULL;
32411 }
32412
32413
32414 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32415 PyObject *resultobj = 0;
32416 wxWindow *arg1 = (wxWindow *) 0 ;
32417 bool arg2 = (bool) true ;
32418 bool result;
32419 void *argp1 = 0 ;
32420 int res1 = 0 ;
32421 bool val2 ;
32422 int ecode2 = 0 ;
32423 PyObject * obj0 = 0 ;
32424 PyObject * obj1 = 0 ;
32425 char * kwnames[] = {
32426 (char *) "self",(char *) "show", NULL
32427 };
32428
32429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32431 if (!SWIG_IsOK(res1)) {
32432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32433 }
32434 arg1 = reinterpret_cast< wxWindow * >(argp1);
32435 if (obj1) {
32436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32437 if (!SWIG_IsOK(ecode2)) {
32438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32439 }
32440 arg2 = static_cast< bool >(val2);
32441 }
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (bool)(arg1)->Show(arg2);
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 {
32449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32450 }
32451 return resultobj;
32452 fail:
32453 return NULL;
32454 }
32455
32456
32457 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32458 PyObject *resultobj = 0;
32459 wxWindow *arg1 = (wxWindow *) 0 ;
32460 bool result;
32461 void *argp1 = 0 ;
32462 int res1 = 0 ;
32463 PyObject *swig_obj[1] ;
32464
32465 if (!args) SWIG_fail;
32466 swig_obj[0] = args;
32467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32468 if (!SWIG_IsOK(res1)) {
32469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32470 }
32471 arg1 = reinterpret_cast< wxWindow * >(argp1);
32472 {
32473 PyThreadState* __tstate = wxPyBeginAllowThreads();
32474 result = (bool)(arg1)->Hide();
32475 wxPyEndAllowThreads(__tstate);
32476 if (PyErr_Occurred()) SWIG_fail;
32477 }
32478 {
32479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32480 }
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32488 PyObject *resultobj = 0;
32489 wxWindow *arg1 = (wxWindow *) 0 ;
32490 bool arg2 = (bool) true ;
32491 bool result;
32492 void *argp1 = 0 ;
32493 int res1 = 0 ;
32494 bool val2 ;
32495 int ecode2 = 0 ;
32496 PyObject * obj0 = 0 ;
32497 PyObject * obj1 = 0 ;
32498 char * kwnames[] = {
32499 (char *) "self",(char *) "enable", NULL
32500 };
32501
32502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32504 if (!SWIG_IsOK(res1)) {
32505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32506 }
32507 arg1 = reinterpret_cast< wxWindow * >(argp1);
32508 if (obj1) {
32509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32510 if (!SWIG_IsOK(ecode2)) {
32511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32512 }
32513 arg2 = static_cast< bool >(val2);
32514 }
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)(arg1)->Enable(arg2);
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxWindow *arg1 = (wxWindow *) 0 ;
32533 bool result;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32543 }
32544 arg1 = reinterpret_cast< wxWindow * >(argp1);
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 result = (bool)(arg1)->Disable();
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 {
32552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32553 }
32554 return resultobj;
32555 fail:
32556 return NULL;
32557 }
32558
32559
32560 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32561 PyObject *resultobj = 0;
32562 wxWindow *arg1 = (wxWindow *) 0 ;
32563 bool result;
32564 void *argp1 = 0 ;
32565 int res1 = 0 ;
32566 PyObject *swig_obj[1] ;
32567
32568 if (!args) SWIG_fail;
32569 swig_obj[0] = args;
32570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32571 if (!SWIG_IsOK(res1)) {
32572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32573 }
32574 arg1 = reinterpret_cast< wxWindow * >(argp1);
32575 {
32576 PyThreadState* __tstate = wxPyBeginAllowThreads();
32577 result = (bool)((wxWindow const *)arg1)->IsShown();
32578 wxPyEndAllowThreads(__tstate);
32579 if (PyErr_Occurred()) SWIG_fail;
32580 }
32581 {
32582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32583 }
32584 return resultobj;
32585 fail:
32586 return NULL;
32587 }
32588
32589
32590 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32591 PyObject *resultobj = 0;
32592 wxWindow *arg1 = (wxWindow *) 0 ;
32593 bool result;
32594 void *argp1 = 0 ;
32595 int res1 = 0 ;
32596 PyObject *swig_obj[1] ;
32597
32598 if (!args) SWIG_fail;
32599 swig_obj[0] = args;
32600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32601 if (!SWIG_IsOK(res1)) {
32602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32603 }
32604 arg1 = reinterpret_cast< wxWindow * >(argp1);
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 {
32612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32613 }
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32621 PyObject *resultobj = 0;
32622 wxWindow *arg1 = (wxWindow *) 0 ;
32623 long arg2 ;
32624 void *argp1 = 0 ;
32625 int res1 = 0 ;
32626 long val2 ;
32627 int ecode2 = 0 ;
32628 PyObject * obj0 = 0 ;
32629 PyObject * obj1 = 0 ;
32630 char * kwnames[] = {
32631 (char *) "self",(char *) "style", NULL
32632 };
32633
32634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32636 if (!SWIG_IsOK(res1)) {
32637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32638 }
32639 arg1 = reinterpret_cast< wxWindow * >(argp1);
32640 ecode2 = SWIG_AsVal_long(obj1, &val2);
32641 if (!SWIG_IsOK(ecode2)) {
32642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32643 }
32644 arg2 = static_cast< long >(val2);
32645 {
32646 PyThreadState* __tstate = wxPyBeginAllowThreads();
32647 (arg1)->SetWindowStyleFlag(arg2);
32648 wxPyEndAllowThreads(__tstate);
32649 if (PyErr_Occurred()) SWIG_fail;
32650 }
32651 resultobj = SWIG_Py_Void();
32652 return resultobj;
32653 fail:
32654 return NULL;
32655 }
32656
32657
32658 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32659 PyObject *resultobj = 0;
32660 wxWindow *arg1 = (wxWindow *) 0 ;
32661 long result;
32662 void *argp1 = 0 ;
32663 int res1 = 0 ;
32664 PyObject *swig_obj[1] ;
32665
32666 if (!args) SWIG_fail;
32667 swig_obj[0] = args;
32668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32669 if (!SWIG_IsOK(res1)) {
32670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32671 }
32672 arg1 = reinterpret_cast< wxWindow * >(argp1);
32673 {
32674 PyThreadState* __tstate = wxPyBeginAllowThreads();
32675 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32676 wxPyEndAllowThreads(__tstate);
32677 if (PyErr_Occurred()) SWIG_fail;
32678 }
32679 resultobj = SWIG_From_long(static_cast< long >(result));
32680 return resultobj;
32681 fail:
32682 return NULL;
32683 }
32684
32685
32686 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj = 0;
32688 wxWindow *arg1 = (wxWindow *) 0 ;
32689 int arg2 ;
32690 bool result;
32691 void *argp1 = 0 ;
32692 int res1 = 0 ;
32693 int val2 ;
32694 int ecode2 = 0 ;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "self",(char *) "flag", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 ecode2 = SWIG_AsVal_int(obj1, &val2);
32708 if (!SWIG_IsOK(ecode2)) {
32709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32710 }
32711 arg2 = static_cast< int >(val2);
32712 {
32713 PyThreadState* __tstate = wxPyBeginAllowThreads();
32714 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 {
32719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32720 }
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxWindow *arg1 = (wxWindow *) 0 ;
32730 bool result;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 PyObject *swig_obj[1] ;
32734
32735 if (!args) SWIG_fail;
32736 swig_obj[0] = args;
32737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32740 }
32741 arg1 = reinterpret_cast< wxWindow * >(argp1);
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 result = (bool)((wxWindow const *)arg1)->IsRetained();
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 {
32749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32750 }
32751 return resultobj;
32752 fail:
32753 return NULL;
32754 }
32755
32756
32757 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32758 PyObject *resultobj = 0;
32759 wxWindow *arg1 = (wxWindow *) 0 ;
32760 long arg2 ;
32761 void *argp1 = 0 ;
32762 int res1 = 0 ;
32763 long val2 ;
32764 int ecode2 = 0 ;
32765 PyObject * obj0 = 0 ;
32766 PyObject * obj1 = 0 ;
32767 char * kwnames[] = {
32768 (char *) "self",(char *) "exStyle", NULL
32769 };
32770
32771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32773 if (!SWIG_IsOK(res1)) {
32774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32775 }
32776 arg1 = reinterpret_cast< wxWindow * >(argp1);
32777 ecode2 = SWIG_AsVal_long(obj1, &val2);
32778 if (!SWIG_IsOK(ecode2)) {
32779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32780 }
32781 arg2 = static_cast< long >(val2);
32782 {
32783 PyThreadState* __tstate = wxPyBeginAllowThreads();
32784 (arg1)->SetExtraStyle(arg2);
32785 wxPyEndAllowThreads(__tstate);
32786 if (PyErr_Occurred()) SWIG_fail;
32787 }
32788 resultobj = SWIG_Py_Void();
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32796 PyObject *resultobj = 0;
32797 wxWindow *arg1 = (wxWindow *) 0 ;
32798 long result;
32799 void *argp1 = 0 ;
32800 int res1 = 0 ;
32801 PyObject *swig_obj[1] ;
32802
32803 if (!args) SWIG_fail;
32804 swig_obj[0] = args;
32805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32808 }
32809 arg1 = reinterpret_cast< wxWindow * >(argp1);
32810 {
32811 PyThreadState* __tstate = wxPyBeginAllowThreads();
32812 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32813 wxPyEndAllowThreads(__tstate);
32814 if (PyErr_Occurred()) SWIG_fail;
32815 }
32816 resultobj = SWIG_From_long(static_cast< long >(result));
32817 return resultobj;
32818 fail:
32819 return NULL;
32820 }
32821
32822
32823 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32824 PyObject *resultobj = 0;
32825 wxWindow *arg1 = (wxWindow *) 0 ;
32826 bool arg2 = (bool) true ;
32827 void *argp1 = 0 ;
32828 int res1 = 0 ;
32829 bool val2 ;
32830 int ecode2 = 0 ;
32831 PyObject * obj0 = 0 ;
32832 PyObject * obj1 = 0 ;
32833 char * kwnames[] = {
32834 (char *) "self",(char *) "modal", NULL
32835 };
32836
32837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32839 if (!SWIG_IsOK(res1)) {
32840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32841 }
32842 arg1 = reinterpret_cast< wxWindow * >(argp1);
32843 if (obj1) {
32844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32845 if (!SWIG_IsOK(ecode2)) {
32846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32847 }
32848 arg2 = static_cast< bool >(val2);
32849 }
32850 {
32851 PyThreadState* __tstate = wxPyBeginAllowThreads();
32852 (arg1)->MakeModal(arg2);
32853 wxPyEndAllowThreads(__tstate);
32854 if (PyErr_Occurred()) SWIG_fail;
32855 }
32856 resultobj = SWIG_Py_Void();
32857 return resultobj;
32858 fail:
32859 return NULL;
32860 }
32861
32862
32863 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32864 PyObject *resultobj = 0;
32865 wxWindow *arg1 = (wxWindow *) 0 ;
32866 bool arg2 ;
32867 void *argp1 = 0 ;
32868 int res1 = 0 ;
32869 bool val2 ;
32870 int ecode2 = 0 ;
32871 PyObject * obj0 = 0 ;
32872 PyObject * obj1 = 0 ;
32873 char * kwnames[] = {
32874 (char *) "self",(char *) "enableTheme", NULL
32875 };
32876
32877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32879 if (!SWIG_IsOK(res1)) {
32880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32881 }
32882 arg1 = reinterpret_cast< wxWindow * >(argp1);
32883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32884 if (!SWIG_IsOK(ecode2)) {
32885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32886 }
32887 arg2 = static_cast< bool >(val2);
32888 {
32889 PyThreadState* __tstate = wxPyBeginAllowThreads();
32890 (arg1)->SetThemeEnabled(arg2);
32891 wxPyEndAllowThreads(__tstate);
32892 if (PyErr_Occurred()) SWIG_fail;
32893 }
32894 resultobj = SWIG_Py_Void();
32895 return resultobj;
32896 fail:
32897 return NULL;
32898 }
32899
32900
32901 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32902 PyObject *resultobj = 0;
32903 wxWindow *arg1 = (wxWindow *) 0 ;
32904 bool result;
32905 void *argp1 = 0 ;
32906 int res1 = 0 ;
32907 PyObject *swig_obj[1] ;
32908
32909 if (!args) SWIG_fail;
32910 swig_obj[0] = args;
32911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32912 if (!SWIG_IsOK(res1)) {
32913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32914 }
32915 arg1 = reinterpret_cast< wxWindow * >(argp1);
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 {
32923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32924 }
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32932 PyObject *resultobj = 0;
32933 wxWindow *arg1 = (wxWindow *) 0 ;
32934 void *argp1 = 0 ;
32935 int res1 = 0 ;
32936 PyObject *swig_obj[1] ;
32937
32938 if (!args) SWIG_fail;
32939 swig_obj[0] = args;
32940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32941 if (!SWIG_IsOK(res1)) {
32942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32943 }
32944 arg1 = reinterpret_cast< wxWindow * >(argp1);
32945 {
32946 PyThreadState* __tstate = wxPyBeginAllowThreads();
32947 (arg1)->SetFocus();
32948 wxPyEndAllowThreads(__tstate);
32949 if (PyErr_Occurred()) SWIG_fail;
32950 }
32951 resultobj = SWIG_Py_Void();
32952 return resultobj;
32953 fail:
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32959 PyObject *resultobj = 0;
32960 wxWindow *arg1 = (wxWindow *) 0 ;
32961 void *argp1 = 0 ;
32962 int res1 = 0 ;
32963 PyObject *swig_obj[1] ;
32964
32965 if (!args) SWIG_fail;
32966 swig_obj[0] = args;
32967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32968 if (!SWIG_IsOK(res1)) {
32969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32970 }
32971 arg1 = reinterpret_cast< wxWindow * >(argp1);
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 (arg1)->SetFocusFromKbd();
32975 wxPyEndAllowThreads(__tstate);
32976 if (PyErr_Occurred()) SWIG_fail;
32977 }
32978 resultobj = SWIG_Py_Void();
32979 return resultobj;
32980 fail:
32981 return NULL;
32982 }
32983
32984
32985 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32986 PyObject *resultobj = 0;
32987 wxWindow *result = 0 ;
32988
32989 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32990 {
32991 if (!wxPyCheckForApp()) SWIG_fail;
32992 PyThreadState* __tstate = wxPyBeginAllowThreads();
32993 result = (wxWindow *)wxWindow::FindFocus();
32994 wxPyEndAllowThreads(__tstate);
32995 if (PyErr_Occurred()) SWIG_fail;
32996 }
32997 {
32998 resultobj = wxPyMake_wxObject(result, 0);
32999 }
33000 return resultobj;
33001 fail:
33002 return NULL;
33003 }
33004
33005
33006 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33007 PyObject *resultobj = 0;
33008 wxWindow *arg1 = (wxWindow *) 0 ;
33009 bool result;
33010 void *argp1 = 0 ;
33011 int res1 = 0 ;
33012 PyObject *swig_obj[1] ;
33013
33014 if (!args) SWIG_fail;
33015 swig_obj[0] = args;
33016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33017 if (!SWIG_IsOK(res1)) {
33018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33019 }
33020 arg1 = reinterpret_cast< wxWindow * >(argp1);
33021 {
33022 PyThreadState* __tstate = wxPyBeginAllowThreads();
33023 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 {
33028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33029 }
33030 return resultobj;
33031 fail:
33032 return NULL;
33033 }
33034
33035
33036 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33037 PyObject *resultobj = 0;
33038 wxWindow *arg1 = (wxWindow *) 0 ;
33039 bool result;
33040 void *argp1 = 0 ;
33041 int res1 = 0 ;
33042 PyObject *swig_obj[1] ;
33043
33044 if (!args) SWIG_fail;
33045 swig_obj[0] = args;
33046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 {
33058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33059 }
33060 return resultobj;
33061 fail:
33062 return NULL;
33063 }
33064
33065
33066 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33067 PyObject *resultobj = 0;
33068 wxWindow *arg1 = (wxWindow *) 0 ;
33069 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33070 bool result;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 int val2 ;
33074 int ecode2 = 0 ;
33075 PyObject * obj0 = 0 ;
33076 PyObject * obj1 = 0 ;
33077 char * kwnames[] = {
33078 (char *) "self",(char *) "flags", NULL
33079 };
33080
33081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33083 if (!SWIG_IsOK(res1)) {
33084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33085 }
33086 arg1 = reinterpret_cast< wxWindow * >(argp1);
33087 if (obj1) {
33088 ecode2 = SWIG_AsVal_int(obj1, &val2);
33089 if (!SWIG_IsOK(ecode2)) {
33090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33091 }
33092 arg2 = static_cast< int >(val2);
33093 }
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 result = (bool)(arg1)->Navigate(arg2);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 {
33101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33102 }
33103 return resultobj;
33104 fail:
33105 return NULL;
33106 }
33107
33108
33109 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33110 PyObject *resultobj = 0;
33111 wxWindow *arg1 = (wxWindow *) 0 ;
33112 wxWindow *arg2 = (wxWindow *) 0 ;
33113 void *argp1 = 0 ;
33114 int res1 = 0 ;
33115 void *argp2 = 0 ;
33116 int res2 = 0 ;
33117 PyObject * obj0 = 0 ;
33118 PyObject * obj1 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "self",(char *) "win", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33125 if (!SWIG_IsOK(res1)) {
33126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33127 }
33128 arg1 = reinterpret_cast< wxWindow * >(argp1);
33129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33130 if (!SWIG_IsOK(res2)) {
33131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33132 }
33133 arg2 = reinterpret_cast< wxWindow * >(argp2);
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 (arg1)->MoveAfterInTabOrder(arg2);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_Py_Void();
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33148 PyObject *resultobj = 0;
33149 wxWindow *arg1 = (wxWindow *) 0 ;
33150 wxWindow *arg2 = (wxWindow *) 0 ;
33151 void *argp1 = 0 ;
33152 int res1 = 0 ;
33153 void *argp2 = 0 ;
33154 int res2 = 0 ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "win", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33168 if (!SWIG_IsOK(res2)) {
33169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33170 }
33171 arg2 = reinterpret_cast< wxWindow * >(argp2);
33172 {
33173 PyThreadState* __tstate = wxPyBeginAllowThreads();
33174 (arg1)->MoveBeforeInTabOrder(arg2);
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 resultobj = SWIG_Py_Void();
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33186 PyObject *resultobj = 0;
33187 wxWindow *arg1 = (wxWindow *) 0 ;
33188 PyObject *result = 0 ;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 PyObject *swig_obj[1] ;
33192
33193 if (!args) SWIG_fail;
33194 swig_obj[0] = args;
33195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33196 if (!SWIG_IsOK(res1)) {
33197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33198 }
33199 arg1 = reinterpret_cast< wxWindow * >(argp1);
33200 {
33201 PyThreadState* __tstate = wxPyBeginAllowThreads();
33202 result = (PyObject *)wxWindow_GetChildren(arg1);
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 resultobj = result;
33207 return resultobj;
33208 fail:
33209 return NULL;
33210 }
33211
33212
33213 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33214 PyObject *resultobj = 0;
33215 wxWindow *arg1 = (wxWindow *) 0 ;
33216 wxWindow *result = 0 ;
33217 void *argp1 = 0 ;
33218 int res1 = 0 ;
33219 PyObject *swig_obj[1] ;
33220
33221 if (!args) SWIG_fail;
33222 swig_obj[0] = args;
33223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33226 }
33227 arg1 = reinterpret_cast< wxWindow * >(argp1);
33228 {
33229 PyThreadState* __tstate = wxPyBeginAllowThreads();
33230 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 {
33235 resultobj = wxPyMake_wxObject(result, 0);
33236 }
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33244 PyObject *resultobj = 0;
33245 wxWindow *arg1 = (wxWindow *) 0 ;
33246 wxWindow *result = 0 ;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 PyObject *swig_obj[1] ;
33250
33251 if (!args) SWIG_fail;
33252 swig_obj[0] = args;
33253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33254 if (!SWIG_IsOK(res1)) {
33255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33256 }
33257 arg1 = reinterpret_cast< wxWindow * >(argp1);
33258 {
33259 PyThreadState* __tstate = wxPyBeginAllowThreads();
33260 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33261 wxPyEndAllowThreads(__tstate);
33262 if (PyErr_Occurred()) SWIG_fail;
33263 }
33264 {
33265 resultobj = wxPyMake_wxObject(result, 0);
33266 }
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33274 PyObject *resultobj = 0;
33275 wxWindow *arg1 = (wxWindow *) 0 ;
33276 bool result;
33277 void *argp1 = 0 ;
33278 int res1 = 0 ;
33279 PyObject *swig_obj[1] ;
33280
33281 if (!args) SWIG_fail;
33282 swig_obj[0] = args;
33283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33284 if (!SWIG_IsOK(res1)) {
33285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33286 }
33287 arg1 = reinterpret_cast< wxWindow * >(argp1);
33288 {
33289 PyThreadState* __tstate = wxPyBeginAllowThreads();
33290 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 {
33295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33296 }
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj = 0;
33305 wxWindow *arg1 = (wxWindow *) 0 ;
33306 wxWindow *arg2 = (wxWindow *) 0 ;
33307 bool result;
33308 void *argp1 = 0 ;
33309 int res1 = 0 ;
33310 void *argp2 = 0 ;
33311 int res2 = 0 ;
33312 PyObject * obj0 = 0 ;
33313 PyObject * obj1 = 0 ;
33314 char * kwnames[] = {
33315 (char *) "self",(char *) "newParent", NULL
33316 };
33317
33318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33320 if (!SWIG_IsOK(res1)) {
33321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33322 }
33323 arg1 = reinterpret_cast< wxWindow * >(argp1);
33324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33325 if (!SWIG_IsOK(res2)) {
33326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33327 }
33328 arg2 = reinterpret_cast< wxWindow * >(argp2);
33329 {
33330 PyThreadState* __tstate = wxPyBeginAllowThreads();
33331 result = (bool)(arg1)->Reparent(arg2);
33332 wxPyEndAllowThreads(__tstate);
33333 if (PyErr_Occurred()) SWIG_fail;
33334 }
33335 {
33336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33337 }
33338 return resultobj;
33339 fail:
33340 return NULL;
33341 }
33342
33343
33344 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33345 PyObject *resultobj = 0;
33346 wxWindow *arg1 = (wxWindow *) 0 ;
33347 wxWindow *arg2 = (wxWindow *) 0 ;
33348 void *argp1 = 0 ;
33349 int res1 = 0 ;
33350 void *argp2 = 0 ;
33351 int res2 = 0 ;
33352 PyObject * obj0 = 0 ;
33353 PyObject * obj1 = 0 ;
33354 char * kwnames[] = {
33355 (char *) "self",(char *) "child", NULL
33356 };
33357
33358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33360 if (!SWIG_IsOK(res1)) {
33361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33362 }
33363 arg1 = reinterpret_cast< wxWindow * >(argp1);
33364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33365 if (!SWIG_IsOK(res2)) {
33366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33367 }
33368 arg2 = reinterpret_cast< wxWindow * >(argp2);
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 (arg1)->AddChild(arg2);
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_Py_Void();
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 wxWindow *arg2 = (wxWindow *) 0 ;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 void *argp2 = 0 ;
33389 int res2 = 0 ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "child", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33403 if (!SWIG_IsOK(res2)) {
33404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33405 }
33406 arg2 = reinterpret_cast< wxWindow * >(argp2);
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 (arg1)->RemoveChild(arg2);
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 resultobj = SWIG_Py_Void();
33414 return resultobj;
33415 fail:
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33421 PyObject *resultobj = 0;
33422 wxWindow *arg1 = (wxWindow *) 0 ;
33423 bool arg2 ;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 bool val2 ;
33427 int ecode2 = 0 ;
33428 PyObject * obj0 = 0 ;
33429 PyObject * obj1 = 0 ;
33430 char * kwnames[] = {
33431 (char *) "self",(char *) "on", NULL
33432 };
33433
33434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33441 if (!SWIG_IsOK(ecode2)) {
33442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33443 }
33444 arg2 = static_cast< bool >(val2);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 wxWindow_SetDoubleBuffered(arg1,arg2);
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 resultobj = SWIG_Py_Void();
33452 return resultobj;
33453 fail:
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33459 PyObject *resultobj = 0;
33460 wxWindow *arg1 = (wxWindow *) 0 ;
33461 long arg2 ;
33462 wxWindow *result = 0 ;
33463 void *argp1 = 0 ;
33464 int res1 = 0 ;
33465 long val2 ;
33466 int ecode2 = 0 ;
33467 PyObject * obj0 = 0 ;
33468 PyObject * obj1 = 0 ;
33469 char * kwnames[] = {
33470 (char *) "self",(char *) "winid", NULL
33471 };
33472
33473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33475 if (!SWIG_IsOK(res1)) {
33476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33477 }
33478 arg1 = reinterpret_cast< wxWindow * >(argp1);
33479 ecode2 = SWIG_AsVal_long(obj1, &val2);
33480 if (!SWIG_IsOK(ecode2)) {
33481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33482 }
33483 arg2 = static_cast< long >(val2);
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (wxWindow *)(arg1)->FindWindow(arg2);
33487 wxPyEndAllowThreads(__tstate);
33488 if (PyErr_Occurred()) SWIG_fail;
33489 }
33490 {
33491 resultobj = wxPyMake_wxObject(result, 0);
33492 }
33493 return resultobj;
33494 fail:
33495 return NULL;
33496 }
33497
33498
33499 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33500 PyObject *resultobj = 0;
33501 wxWindow *arg1 = (wxWindow *) 0 ;
33502 wxString *arg2 = 0 ;
33503 wxWindow *result = 0 ;
33504 void *argp1 = 0 ;
33505 int res1 = 0 ;
33506 bool temp2 = false ;
33507 PyObject * obj0 = 0 ;
33508 PyObject * obj1 = 0 ;
33509 char * kwnames[] = {
33510 (char *) "self",(char *) "name", NULL
33511 };
33512
33513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33515 if (!SWIG_IsOK(res1)) {
33516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33517 }
33518 arg1 = reinterpret_cast< wxWindow * >(argp1);
33519 {
33520 arg2 = wxString_in_helper(obj1);
33521 if (arg2 == NULL) SWIG_fail;
33522 temp2 = true;
33523 }
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 {
33531 resultobj = wxPyMake_wxObject(result, 0);
33532 }
33533 {
33534 if (temp2)
33535 delete arg2;
33536 }
33537 return resultobj;
33538 fail:
33539 {
33540 if (temp2)
33541 delete arg2;
33542 }
33543 return NULL;
33544 }
33545
33546
33547 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 PyObject *resultobj = 0;
33549 wxWindow *arg1 = (wxWindow *) 0 ;
33550 wxEvtHandler *result = 0 ;
33551 void *argp1 = 0 ;
33552 int res1 = 0 ;
33553 PyObject *swig_obj[1] ;
33554
33555 if (!args) SWIG_fail;
33556 swig_obj[0] = args;
33557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33558 if (!SWIG_IsOK(res1)) {
33559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33560 }
33561 arg1 = reinterpret_cast< wxWindow * >(argp1);
33562 {
33563 PyThreadState* __tstate = wxPyBeginAllowThreads();
33564 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33565 wxPyEndAllowThreads(__tstate);
33566 if (PyErr_Occurred()) SWIG_fail;
33567 }
33568 {
33569 resultobj = wxPyMake_wxObject(result, 0);
33570 }
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj = 0;
33579 wxWindow *arg1 = (wxWindow *) 0 ;
33580 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33581 void *argp1 = 0 ;
33582 int res1 = 0 ;
33583 void *argp2 = 0 ;
33584 int res2 = 0 ;
33585 PyObject * obj0 = 0 ;
33586 PyObject * obj1 = 0 ;
33587 char * kwnames[] = {
33588 (char *) "self",(char *) "handler", NULL
33589 };
33590
33591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33593 if (!SWIG_IsOK(res1)) {
33594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33595 }
33596 arg1 = reinterpret_cast< wxWindow * >(argp1);
33597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33598 if (!SWIG_IsOK(res2)) {
33599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33600 }
33601 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33602 {
33603 PyThreadState* __tstate = wxPyBeginAllowThreads();
33604 (arg1)->SetEventHandler(arg2);
33605 wxPyEndAllowThreads(__tstate);
33606 if (PyErr_Occurred()) SWIG_fail;
33607 }
33608 resultobj = SWIG_Py_Void();
33609 return resultobj;
33610 fail:
33611 return NULL;
33612 }
33613
33614
33615 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj = 0;
33617 wxWindow *arg1 = (wxWindow *) 0 ;
33618 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33619 void *argp1 = 0 ;
33620 int res1 = 0 ;
33621 void *argp2 = 0 ;
33622 int res2 = 0 ;
33623 PyObject * obj0 = 0 ;
33624 PyObject * obj1 = 0 ;
33625 char * kwnames[] = {
33626 (char *) "self",(char *) "handler", NULL
33627 };
33628
33629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33631 if (!SWIG_IsOK(res1)) {
33632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33633 }
33634 arg1 = reinterpret_cast< wxWindow * >(argp1);
33635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33636 if (!SWIG_IsOK(res2)) {
33637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33638 }
33639 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33640 {
33641 PyThreadState* __tstate = wxPyBeginAllowThreads();
33642 (arg1)->PushEventHandler(arg2);
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 resultobj = SWIG_Py_Void();
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33654 PyObject *resultobj = 0;
33655 wxWindow *arg1 = (wxWindow *) 0 ;
33656 bool arg2 = (bool) false ;
33657 wxEvtHandler *result = 0 ;
33658 void *argp1 = 0 ;
33659 int res1 = 0 ;
33660 bool val2 ;
33661 int ecode2 = 0 ;
33662 PyObject * obj0 = 0 ;
33663 PyObject * obj1 = 0 ;
33664 char * kwnames[] = {
33665 (char *) "self",(char *) "deleteHandler", NULL
33666 };
33667
33668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33670 if (!SWIG_IsOK(res1)) {
33671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33672 }
33673 arg1 = reinterpret_cast< wxWindow * >(argp1);
33674 if (obj1) {
33675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33676 if (!SWIG_IsOK(ecode2)) {
33677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33678 }
33679 arg2 = static_cast< bool >(val2);
33680 }
33681 {
33682 PyThreadState* __tstate = wxPyBeginAllowThreads();
33683 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33684 wxPyEndAllowThreads(__tstate);
33685 if (PyErr_Occurred()) SWIG_fail;
33686 }
33687 {
33688 resultobj = wxPyMake_wxObject(result, 0);
33689 }
33690 return resultobj;
33691 fail:
33692 return NULL;
33693 }
33694
33695
33696 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33697 PyObject *resultobj = 0;
33698 wxWindow *arg1 = (wxWindow *) 0 ;
33699 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33700 bool result;
33701 void *argp1 = 0 ;
33702 int res1 = 0 ;
33703 void *argp2 = 0 ;
33704 int res2 = 0 ;
33705 PyObject * obj0 = 0 ;
33706 PyObject * obj1 = 0 ;
33707 char * kwnames[] = {
33708 (char *) "self",(char *) "handler", NULL
33709 };
33710
33711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33713 if (!SWIG_IsOK(res1)) {
33714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33715 }
33716 arg1 = reinterpret_cast< wxWindow * >(argp1);
33717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33718 if (!SWIG_IsOK(res2)) {
33719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33720 }
33721 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33722 {
33723 PyThreadState* __tstate = wxPyBeginAllowThreads();
33724 result = (bool)(arg1)->RemoveEventHandler(arg2);
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 {
33729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33730 }
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxWindow *arg1 = (wxWindow *) 0 ;
33740 wxValidator *arg2 = 0 ;
33741 void *argp1 = 0 ;
33742 int res1 = 0 ;
33743 void *argp2 = 0 ;
33744 int res2 = 0 ;
33745 PyObject * obj0 = 0 ;
33746 PyObject * obj1 = 0 ;
33747 char * kwnames[] = {
33748 (char *) "self",(char *) "validator", NULL
33749 };
33750
33751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33753 if (!SWIG_IsOK(res1)) {
33754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33755 }
33756 arg1 = reinterpret_cast< wxWindow * >(argp1);
33757 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33758 if (!SWIG_IsOK(res2)) {
33759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33760 }
33761 if (!argp2) {
33762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33763 }
33764 arg2 = reinterpret_cast< wxValidator * >(argp2);
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 (arg1)->SetValidator((wxValidator const &)*arg2);
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 resultobj = SWIG_Py_Void();
33772 return resultobj;
33773 fail:
33774 return NULL;
33775 }
33776
33777
33778 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33779 PyObject *resultobj = 0;
33780 wxWindow *arg1 = (wxWindow *) 0 ;
33781 wxValidator *result = 0 ;
33782 void *argp1 = 0 ;
33783 int res1 = 0 ;
33784 PyObject *swig_obj[1] ;
33785
33786 if (!args) SWIG_fail;
33787 swig_obj[0] = args;
33788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33789 if (!SWIG_IsOK(res1)) {
33790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33791 }
33792 arg1 = reinterpret_cast< wxWindow * >(argp1);
33793 {
33794 PyThreadState* __tstate = wxPyBeginAllowThreads();
33795 result = (wxValidator *)(arg1)->GetValidator();
33796 wxPyEndAllowThreads(__tstate);
33797 if (PyErr_Occurred()) SWIG_fail;
33798 }
33799 {
33800 resultobj = wxPyMake_wxObject(result, (bool)0);
33801 }
33802 return resultobj;
33803 fail:
33804 return NULL;
33805 }
33806
33807
33808 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33809 PyObject *resultobj = 0;
33810 wxWindow *arg1 = (wxWindow *) 0 ;
33811 bool result;
33812 void *argp1 = 0 ;
33813 int res1 = 0 ;
33814 PyObject *swig_obj[1] ;
33815
33816 if (!args) SWIG_fail;
33817 swig_obj[0] = args;
33818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33819 if (!SWIG_IsOK(res1)) {
33820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33821 }
33822 arg1 = reinterpret_cast< wxWindow * >(argp1);
33823 {
33824 PyThreadState* __tstate = wxPyBeginAllowThreads();
33825 result = (bool)(arg1)->Validate();
33826 wxPyEndAllowThreads(__tstate);
33827 if (PyErr_Occurred()) SWIG_fail;
33828 }
33829 {
33830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33831 }
33832 return resultobj;
33833 fail:
33834 return NULL;
33835 }
33836
33837
33838 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33839 PyObject *resultobj = 0;
33840 wxWindow *arg1 = (wxWindow *) 0 ;
33841 bool result;
33842 void *argp1 = 0 ;
33843 int res1 = 0 ;
33844 PyObject *swig_obj[1] ;
33845
33846 if (!args) SWIG_fail;
33847 swig_obj[0] = args;
33848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33849 if (!SWIG_IsOK(res1)) {
33850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33851 }
33852 arg1 = reinterpret_cast< wxWindow * >(argp1);
33853 {
33854 PyThreadState* __tstate = wxPyBeginAllowThreads();
33855 result = (bool)(arg1)->TransferDataToWindow();
33856 wxPyEndAllowThreads(__tstate);
33857 if (PyErr_Occurred()) SWIG_fail;
33858 }
33859 {
33860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33861 }
33862 return resultobj;
33863 fail:
33864 return NULL;
33865 }
33866
33867
33868 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33869 PyObject *resultobj = 0;
33870 wxWindow *arg1 = (wxWindow *) 0 ;
33871 bool result;
33872 void *argp1 = 0 ;
33873 int res1 = 0 ;
33874 PyObject *swig_obj[1] ;
33875
33876 if (!args) SWIG_fail;
33877 swig_obj[0] = args;
33878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33879 if (!SWIG_IsOK(res1)) {
33880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33881 }
33882 arg1 = reinterpret_cast< wxWindow * >(argp1);
33883 {
33884 PyThreadState* __tstate = wxPyBeginAllowThreads();
33885 result = (bool)(arg1)->TransferDataFromWindow();
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 {
33890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33891 }
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33899 PyObject *resultobj = 0;
33900 wxWindow *arg1 = (wxWindow *) 0 ;
33901 void *argp1 = 0 ;
33902 int res1 = 0 ;
33903 PyObject *swig_obj[1] ;
33904
33905 if (!args) SWIG_fail;
33906 swig_obj[0] = args;
33907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33908 if (!SWIG_IsOK(res1)) {
33909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33910 }
33911 arg1 = reinterpret_cast< wxWindow * >(argp1);
33912 {
33913 PyThreadState* __tstate = wxPyBeginAllowThreads();
33914 (arg1)->InitDialog();
33915 wxPyEndAllowThreads(__tstate);
33916 if (PyErr_Occurred()) SWIG_fail;
33917 }
33918 resultobj = SWIG_Py_Void();
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33926 PyObject *resultobj = 0;
33927 wxWindow *arg1 = (wxWindow *) 0 ;
33928 wxAcceleratorTable *arg2 = 0 ;
33929 void *argp1 = 0 ;
33930 int res1 = 0 ;
33931 void *argp2 = 0 ;
33932 int res2 = 0 ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 char * kwnames[] = {
33936 (char *) "self",(char *) "accel", NULL
33937 };
33938
33939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33941 if (!SWIG_IsOK(res1)) {
33942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33943 }
33944 arg1 = reinterpret_cast< wxWindow * >(argp1);
33945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33946 if (!SWIG_IsOK(res2)) {
33947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33948 }
33949 if (!argp2) {
33950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33951 }
33952 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_Py_Void();
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33967 PyObject *resultobj = 0;
33968 wxWindow *arg1 = (wxWindow *) 0 ;
33969 wxAcceleratorTable *result = 0 ;
33970 void *argp1 = 0 ;
33971 int res1 = 0 ;
33972 PyObject *swig_obj[1] ;
33973
33974 if (!args) SWIG_fail;
33975 swig_obj[0] = args;
33976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33979 }
33980 arg1 = reinterpret_cast< wxWindow * >(argp1);
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33995 PyObject *resultobj = 0;
33996 wxWindow *arg1 = (wxWindow *) 0 ;
33997 int arg2 ;
33998 int arg3 ;
33999 int arg4 ;
34000 bool result;
34001 void *argp1 = 0 ;
34002 int res1 = 0 ;
34003 int val2 ;
34004 int ecode2 = 0 ;
34005 int val3 ;
34006 int ecode3 = 0 ;
34007 int val4 ;
34008 int ecode4 = 0 ;
34009 PyObject * obj0 = 0 ;
34010 PyObject * obj1 = 0 ;
34011 PyObject * obj2 = 0 ;
34012 PyObject * obj3 = 0 ;
34013 char * kwnames[] = {
34014 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34015 };
34016
34017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34019 if (!SWIG_IsOK(res1)) {
34020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34021 }
34022 arg1 = reinterpret_cast< wxWindow * >(argp1);
34023 ecode2 = SWIG_AsVal_int(obj1, &val2);
34024 if (!SWIG_IsOK(ecode2)) {
34025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34026 }
34027 arg2 = static_cast< int >(val2);
34028 ecode3 = SWIG_AsVal_int(obj2, &val3);
34029 if (!SWIG_IsOK(ecode3)) {
34030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34031 }
34032 arg3 = static_cast< int >(val3);
34033 ecode4 = SWIG_AsVal_int(obj3, &val4);
34034 if (!SWIG_IsOK(ecode4)) {
34035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34036 }
34037 arg4 = static_cast< int >(val4);
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 {
34045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34046 }
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34054 PyObject *resultobj = 0;
34055 wxWindow *arg1 = (wxWindow *) 0 ;
34056 int arg2 ;
34057 bool result;
34058 void *argp1 = 0 ;
34059 int res1 = 0 ;
34060 int val2 ;
34061 int ecode2 = 0 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "hotkeyId", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 ecode2 = SWIG_AsVal_int(obj1, &val2);
34075 if (!SWIG_IsOK(ecode2)) {
34076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34077 }
34078 arg2 = static_cast< int >(val2);
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34082 wxPyEndAllowThreads(__tstate);
34083 if (PyErr_Occurred()) SWIG_fail;
34084 }
34085 {
34086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34087 }
34088 return resultobj;
34089 fail:
34090 return NULL;
34091 }
34092
34093
34094 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34095 PyObject *resultobj = 0;
34096 wxWindow *arg1 = (wxWindow *) 0 ;
34097 wxPoint *arg2 = 0 ;
34098 wxPoint result;
34099 void *argp1 = 0 ;
34100 int res1 = 0 ;
34101 wxPoint temp2 ;
34102 PyObject * obj0 = 0 ;
34103 PyObject * obj1 = 0 ;
34104 char * kwnames[] = {
34105 (char *) "self",(char *) "pt", NULL
34106 };
34107
34108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34110 if (!SWIG_IsOK(res1)) {
34111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34112 }
34113 arg1 = reinterpret_cast< wxWindow * >(argp1);
34114 {
34115 arg2 = &temp2;
34116 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34117 }
34118 {
34119 PyThreadState* __tstate = wxPyBeginAllowThreads();
34120 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34121 wxPyEndAllowThreads(__tstate);
34122 if (PyErr_Occurred()) SWIG_fail;
34123 }
34124 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34125 return resultobj;
34126 fail:
34127 return NULL;
34128 }
34129
34130
34131 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34132 PyObject *resultobj = 0;
34133 wxWindow *arg1 = (wxWindow *) 0 ;
34134 wxSize *arg2 = 0 ;
34135 wxSize result;
34136 void *argp1 = 0 ;
34137 int res1 = 0 ;
34138 wxSize temp2 ;
34139 PyObject * obj0 = 0 ;
34140 PyObject * obj1 = 0 ;
34141 char * kwnames[] = {
34142 (char *) "self",(char *) "sz", NULL
34143 };
34144
34145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34147 if (!SWIG_IsOK(res1)) {
34148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34149 }
34150 arg1 = reinterpret_cast< wxWindow * >(argp1);
34151 {
34152 arg2 = &temp2;
34153 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34154 }
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34162 return resultobj;
34163 fail:
34164 return NULL;
34165 }
34166
34167
34168 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34169 PyObject *resultobj = 0;
34170 wxWindow *arg1 = (wxWindow *) 0 ;
34171 wxPoint *arg2 = 0 ;
34172 wxPoint result;
34173 void *argp1 = 0 ;
34174 int res1 = 0 ;
34175 wxPoint temp2 ;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 char * kwnames[] = {
34179 (char *) "self",(char *) "pt", NULL
34180 };
34181
34182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34184 if (!SWIG_IsOK(res1)) {
34185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34186 }
34187 arg1 = reinterpret_cast< wxWindow * >(argp1);
34188 {
34189 arg2 = &temp2;
34190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34191 }
34192 {
34193 PyThreadState* __tstate = wxPyBeginAllowThreads();
34194 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34195 wxPyEndAllowThreads(__tstate);
34196 if (PyErr_Occurred()) SWIG_fail;
34197 }
34198 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj = 0;
34207 wxWindow *arg1 = (wxWindow *) 0 ;
34208 wxSize *arg2 = 0 ;
34209 wxSize result;
34210 void *argp1 = 0 ;
34211 int res1 = 0 ;
34212 wxSize temp2 ;
34213 PyObject * obj0 = 0 ;
34214 PyObject * obj1 = 0 ;
34215 char * kwnames[] = {
34216 (char *) "self",(char *) "sz", NULL
34217 };
34218
34219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 arg2 = &temp2;
34227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34228 }
34229 {
34230 PyThreadState* __tstate = wxPyBeginAllowThreads();
34231 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34243 PyObject *resultobj = 0;
34244 wxWindow *arg1 = (wxWindow *) 0 ;
34245 wxPoint *arg2 = 0 ;
34246 wxPoint result;
34247 void *argp1 = 0 ;
34248 int res1 = 0 ;
34249 wxPoint temp2 ;
34250 PyObject * obj0 = 0 ;
34251 PyObject * obj1 = 0 ;
34252 char * kwnames[] = {
34253 (char *) "self",(char *) "pt", NULL
34254 };
34255
34256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34258 if (!SWIG_IsOK(res1)) {
34259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34260 }
34261 arg1 = reinterpret_cast< wxWindow * >(argp1);
34262 {
34263 arg2 = &temp2;
34264 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34265 }
34266 {
34267 PyThreadState* __tstate = wxPyBeginAllowThreads();
34268 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34273 return resultobj;
34274 fail:
34275 return NULL;
34276 }
34277
34278
34279 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34280 PyObject *resultobj = 0;
34281 wxWindow *arg1 = (wxWindow *) 0 ;
34282 wxSize *arg2 = 0 ;
34283 wxSize result;
34284 void *argp1 = 0 ;
34285 int res1 = 0 ;
34286 wxSize temp2 ;
34287 PyObject * obj0 = 0 ;
34288 PyObject * obj1 = 0 ;
34289 char * kwnames[] = {
34290 (char *) "self",(char *) "sz", NULL
34291 };
34292
34293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34295 if (!SWIG_IsOK(res1)) {
34296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34297 }
34298 arg1 = reinterpret_cast< wxWindow * >(argp1);
34299 {
34300 arg2 = &temp2;
34301 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34302 }
34303 {
34304 PyThreadState* __tstate = wxPyBeginAllowThreads();
34305 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34306 wxPyEndAllowThreads(__tstate);
34307 if (PyErr_Occurred()) SWIG_fail;
34308 }
34309 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34317 PyObject *resultobj = 0;
34318 wxWindow *arg1 = (wxWindow *) 0 ;
34319 int arg2 ;
34320 int arg3 ;
34321 void *argp1 = 0 ;
34322 int res1 = 0 ;
34323 int val2 ;
34324 int ecode2 = 0 ;
34325 int val3 ;
34326 int ecode3 = 0 ;
34327 PyObject * obj0 = 0 ;
34328 PyObject * obj1 = 0 ;
34329 PyObject * obj2 = 0 ;
34330 char * kwnames[] = {
34331 (char *) "self",(char *) "x",(char *) "y", NULL
34332 };
34333
34334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34336 if (!SWIG_IsOK(res1)) {
34337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34338 }
34339 arg1 = reinterpret_cast< wxWindow * >(argp1);
34340 ecode2 = SWIG_AsVal_int(obj1, &val2);
34341 if (!SWIG_IsOK(ecode2)) {
34342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34343 }
34344 arg2 = static_cast< int >(val2);
34345 ecode3 = SWIG_AsVal_int(obj2, &val3);
34346 if (!SWIG_IsOK(ecode3)) {
34347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34348 }
34349 arg3 = static_cast< int >(val3);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 (arg1)->WarpPointer(arg2,arg3);
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 resultobj = SWIG_Py_Void();
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34364 PyObject *resultobj = 0;
34365 wxWindow *arg1 = (wxWindow *) 0 ;
34366 void *argp1 = 0 ;
34367 int res1 = 0 ;
34368 PyObject *swig_obj[1] ;
34369
34370 if (!args) SWIG_fail;
34371 swig_obj[0] = args;
34372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34373 if (!SWIG_IsOK(res1)) {
34374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34375 }
34376 arg1 = reinterpret_cast< wxWindow * >(argp1);
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 (arg1)->CaptureMouse();
34380 wxPyEndAllowThreads(__tstate);
34381 if (PyErr_Occurred()) SWIG_fail;
34382 }
34383 resultobj = SWIG_Py_Void();
34384 return resultobj;
34385 fail:
34386 return NULL;
34387 }
34388
34389
34390 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34391 PyObject *resultobj = 0;
34392 wxWindow *arg1 = (wxWindow *) 0 ;
34393 void *argp1 = 0 ;
34394 int res1 = 0 ;
34395 PyObject *swig_obj[1] ;
34396
34397 if (!args) SWIG_fail;
34398 swig_obj[0] = args;
34399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34400 if (!SWIG_IsOK(res1)) {
34401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34402 }
34403 arg1 = reinterpret_cast< wxWindow * >(argp1);
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 (arg1)->ReleaseMouse();
34407 wxPyEndAllowThreads(__tstate);
34408 if (PyErr_Occurred()) SWIG_fail;
34409 }
34410 resultobj = SWIG_Py_Void();
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34418 PyObject *resultobj = 0;
34419 wxWindow *result = 0 ;
34420
34421 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34422 {
34423 if (!wxPyCheckForApp()) SWIG_fail;
34424 PyThreadState* __tstate = wxPyBeginAllowThreads();
34425 result = (wxWindow *)wxWindow::GetCapture();
34426 wxPyEndAllowThreads(__tstate);
34427 if (PyErr_Occurred()) SWIG_fail;
34428 }
34429 {
34430 resultobj = wxPyMake_wxObject(result, 0);
34431 }
34432 return resultobj;
34433 fail:
34434 return NULL;
34435 }
34436
34437
34438 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34439 PyObject *resultobj = 0;
34440 wxWindow *arg1 = (wxWindow *) 0 ;
34441 bool result;
34442 void *argp1 = 0 ;
34443 int res1 = 0 ;
34444 PyObject *swig_obj[1] ;
34445
34446 if (!args) SWIG_fail;
34447 swig_obj[0] = args;
34448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34449 if (!SWIG_IsOK(res1)) {
34450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34451 }
34452 arg1 = reinterpret_cast< wxWindow * >(argp1);
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 result = (bool)((wxWindow const *)arg1)->HasCapture();
34456 wxPyEndAllowThreads(__tstate);
34457 if (PyErr_Occurred()) SWIG_fail;
34458 }
34459 {
34460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34461 }
34462 return resultobj;
34463 fail:
34464 return NULL;
34465 }
34466
34467
34468 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34469 PyObject *resultobj = 0;
34470 wxWindow *arg1 = (wxWindow *) 0 ;
34471 bool arg2 = (bool) true ;
34472 wxRect *arg3 = (wxRect *) NULL ;
34473 void *argp1 = 0 ;
34474 int res1 = 0 ;
34475 bool val2 ;
34476 int ecode2 = 0 ;
34477 void *argp3 = 0 ;
34478 int res3 = 0 ;
34479 PyObject * obj0 = 0 ;
34480 PyObject * obj1 = 0 ;
34481 PyObject * obj2 = 0 ;
34482 char * kwnames[] = {
34483 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34484 };
34485
34486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34490 }
34491 arg1 = reinterpret_cast< wxWindow * >(argp1);
34492 if (obj1) {
34493 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34494 if (!SWIG_IsOK(ecode2)) {
34495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34496 }
34497 arg2 = static_cast< bool >(val2);
34498 }
34499 if (obj2) {
34500 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34501 if (!SWIG_IsOK(res3)) {
34502 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34503 }
34504 arg3 = reinterpret_cast< wxRect * >(argp3);
34505 }
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34509 wxPyEndAllowThreads(__tstate);
34510 if (PyErr_Occurred()) SWIG_fail;
34511 }
34512 resultobj = SWIG_Py_Void();
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34520 PyObject *resultobj = 0;
34521 wxWindow *arg1 = (wxWindow *) 0 ;
34522 wxRect *arg2 = 0 ;
34523 bool arg3 = (bool) true ;
34524 void *argp1 = 0 ;
34525 int res1 = 0 ;
34526 wxRect temp2 ;
34527 bool val3 ;
34528 int ecode3 = 0 ;
34529 PyObject * obj0 = 0 ;
34530 PyObject * obj1 = 0 ;
34531 PyObject * obj2 = 0 ;
34532 char * kwnames[] = {
34533 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34534 };
34535
34536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34538 if (!SWIG_IsOK(res1)) {
34539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34540 }
34541 arg1 = reinterpret_cast< wxWindow * >(argp1);
34542 {
34543 arg2 = &temp2;
34544 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34545 }
34546 if (obj2) {
34547 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34548 if (!SWIG_IsOK(ecode3)) {
34549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34550 }
34551 arg3 = static_cast< bool >(val3);
34552 }
34553 {
34554 PyThreadState* __tstate = wxPyBeginAllowThreads();
34555 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34556 wxPyEndAllowThreads(__tstate);
34557 if (PyErr_Occurred()) SWIG_fail;
34558 }
34559 resultobj = SWIG_Py_Void();
34560 return resultobj;
34561 fail:
34562 return NULL;
34563 }
34564
34565
34566 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34567 PyObject *resultobj = 0;
34568 wxWindow *arg1 = (wxWindow *) 0 ;
34569 void *argp1 = 0 ;
34570 int res1 = 0 ;
34571 PyObject *swig_obj[1] ;
34572
34573 if (!args) SWIG_fail;
34574 swig_obj[0] = args;
34575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34576 if (!SWIG_IsOK(res1)) {
34577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34578 }
34579 arg1 = reinterpret_cast< wxWindow * >(argp1);
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 (arg1)->Update();
34583 wxPyEndAllowThreads(__tstate);
34584 if (PyErr_Occurred()) SWIG_fail;
34585 }
34586 resultobj = SWIG_Py_Void();
34587 return resultobj;
34588 fail:
34589 return NULL;
34590 }
34591
34592
34593 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34594 PyObject *resultobj = 0;
34595 wxWindow *arg1 = (wxWindow *) 0 ;
34596 void *argp1 = 0 ;
34597 int res1 = 0 ;
34598 PyObject *swig_obj[1] ;
34599
34600 if (!args) SWIG_fail;
34601 swig_obj[0] = args;
34602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34603 if (!SWIG_IsOK(res1)) {
34604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34605 }
34606 arg1 = reinterpret_cast< wxWindow * >(argp1);
34607 {
34608 PyThreadState* __tstate = wxPyBeginAllowThreads();
34609 (arg1)->ClearBackground();
34610 wxPyEndAllowThreads(__tstate);
34611 if (PyErr_Occurred()) SWIG_fail;
34612 }
34613 resultobj = SWIG_Py_Void();
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34621 PyObject *resultobj = 0;
34622 wxWindow *arg1 = (wxWindow *) 0 ;
34623 void *argp1 = 0 ;
34624 int res1 = 0 ;
34625 PyObject *swig_obj[1] ;
34626
34627 if (!args) SWIG_fail;
34628 swig_obj[0] = args;
34629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34630 if (!SWIG_IsOK(res1)) {
34631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34632 }
34633 arg1 = reinterpret_cast< wxWindow * >(argp1);
34634 {
34635 PyThreadState* __tstate = wxPyBeginAllowThreads();
34636 (arg1)->Freeze();
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 resultobj = SWIG_Py_Void();
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34648 PyObject *resultobj = 0;
34649 wxWindow *arg1 = (wxWindow *) 0 ;
34650 void *argp1 = 0 ;
34651 int res1 = 0 ;
34652 PyObject *swig_obj[1] ;
34653
34654 if (!args) SWIG_fail;
34655 swig_obj[0] = args;
34656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34657 if (!SWIG_IsOK(res1)) {
34658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34659 }
34660 arg1 = reinterpret_cast< wxWindow * >(argp1);
34661 {
34662 PyThreadState* __tstate = wxPyBeginAllowThreads();
34663 (arg1)->Thaw();
34664 wxPyEndAllowThreads(__tstate);
34665 if (PyErr_Occurred()) SWIG_fail;
34666 }
34667 resultobj = SWIG_Py_Void();
34668 return resultobj;
34669 fail:
34670 return NULL;
34671 }
34672
34673
34674 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34675 PyObject *resultobj = 0;
34676 wxWindow *arg1 = (wxWindow *) 0 ;
34677 wxDC *arg2 = 0 ;
34678 void *argp1 = 0 ;
34679 int res1 = 0 ;
34680 void *argp2 = 0 ;
34681 int res2 = 0 ;
34682 PyObject * obj0 = 0 ;
34683 PyObject * obj1 = 0 ;
34684 char * kwnames[] = {
34685 (char *) "self",(char *) "dc", NULL
34686 };
34687
34688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34690 if (!SWIG_IsOK(res1)) {
34691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34692 }
34693 arg1 = reinterpret_cast< wxWindow * >(argp1);
34694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34695 if (!SWIG_IsOK(res2)) {
34696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34697 }
34698 if (!argp2) {
34699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34700 }
34701 arg2 = reinterpret_cast< wxDC * >(argp2);
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 (arg1)->PrepareDC(*arg2);
34705 wxPyEndAllowThreads(__tstate);
34706 if (PyErr_Occurred()) SWIG_fail;
34707 }
34708 resultobj = SWIG_Py_Void();
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34716 PyObject *resultobj = 0;
34717 wxWindow *arg1 = (wxWindow *) 0 ;
34718 wxRegion *result = 0 ;
34719 void *argp1 = 0 ;
34720 int res1 = 0 ;
34721 PyObject *swig_obj[1] ;
34722
34723 if (!args) SWIG_fail;
34724 swig_obj[0] = args;
34725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 {
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 {
34733 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34734 result = (wxRegion *) &_result_ref;
34735 }
34736 wxPyEndAllowThreads(__tstate);
34737 if (PyErr_Occurred()) SWIG_fail;
34738 }
34739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34740 return resultobj;
34741 fail:
34742 return NULL;
34743 }
34744
34745
34746 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34747 PyObject *resultobj = 0;
34748 wxWindow *arg1 = (wxWindow *) 0 ;
34749 wxRect result;
34750 void *argp1 = 0 ;
34751 int res1 = 0 ;
34752 PyObject *swig_obj[1] ;
34753
34754 if (!args) SWIG_fail;
34755 swig_obj[0] = args;
34756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34757 if (!SWIG_IsOK(res1)) {
34758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34759 }
34760 arg1 = reinterpret_cast< wxWindow * >(argp1);
34761 {
34762 PyThreadState* __tstate = wxPyBeginAllowThreads();
34763 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34764 wxPyEndAllowThreads(__tstate);
34765 if (PyErr_Occurred()) SWIG_fail;
34766 }
34767 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34768 return resultobj;
34769 fail:
34770 return NULL;
34771 }
34772
34773
34774 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34775 PyObject *resultobj = 0;
34776 wxWindow *arg1 = (wxWindow *) 0 ;
34777 int arg2 ;
34778 int arg3 ;
34779 int arg4 = (int) 1 ;
34780 int arg5 = (int) 1 ;
34781 bool result;
34782 void *argp1 = 0 ;
34783 int res1 = 0 ;
34784 int val2 ;
34785 int ecode2 = 0 ;
34786 int val3 ;
34787 int ecode3 = 0 ;
34788 int val4 ;
34789 int ecode4 = 0 ;
34790 int val5 ;
34791 int ecode5 = 0 ;
34792 PyObject * obj0 = 0 ;
34793 PyObject * obj1 = 0 ;
34794 PyObject * obj2 = 0 ;
34795 PyObject * obj3 = 0 ;
34796 PyObject * obj4 = 0 ;
34797 char * kwnames[] = {
34798 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34799 };
34800
34801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34803 if (!SWIG_IsOK(res1)) {
34804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34805 }
34806 arg1 = reinterpret_cast< wxWindow * >(argp1);
34807 ecode2 = SWIG_AsVal_int(obj1, &val2);
34808 if (!SWIG_IsOK(ecode2)) {
34809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34810 }
34811 arg2 = static_cast< int >(val2);
34812 ecode3 = SWIG_AsVal_int(obj2, &val3);
34813 if (!SWIG_IsOK(ecode3)) {
34814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34815 }
34816 arg3 = static_cast< int >(val3);
34817 if (obj3) {
34818 ecode4 = SWIG_AsVal_int(obj3, &val4);
34819 if (!SWIG_IsOK(ecode4)) {
34820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34821 }
34822 arg4 = static_cast< int >(val4);
34823 }
34824 if (obj4) {
34825 ecode5 = SWIG_AsVal_int(obj4, &val5);
34826 if (!SWIG_IsOK(ecode5)) {
34827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34828 }
34829 arg5 = static_cast< int >(val5);
34830 }
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 {
34838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34839 }
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj = 0;
34848 wxWindow *arg1 = (wxWindow *) 0 ;
34849 wxPoint *arg2 = 0 ;
34850 bool result;
34851 void *argp1 = 0 ;
34852 int res1 = 0 ;
34853 wxPoint temp2 ;
34854 PyObject * obj0 = 0 ;
34855 PyObject * obj1 = 0 ;
34856 char * kwnames[] = {
34857 (char *) "self",(char *) "pt", NULL
34858 };
34859
34860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34862 if (!SWIG_IsOK(res1)) {
34863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34864 }
34865 arg1 = reinterpret_cast< wxWindow * >(argp1);
34866 {
34867 arg2 = &temp2;
34868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34869 }
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34873 wxPyEndAllowThreads(__tstate);
34874 if (PyErr_Occurred()) SWIG_fail;
34875 }
34876 {
34877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34878 }
34879 return resultobj;
34880 fail:
34881 return NULL;
34882 }
34883
34884
34885 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34886 PyObject *resultobj = 0;
34887 wxWindow *arg1 = (wxWindow *) 0 ;
34888 wxRect *arg2 = 0 ;
34889 bool result;
34890 void *argp1 = 0 ;
34891 int res1 = 0 ;
34892 wxRect temp2 ;
34893 PyObject * obj0 = 0 ;
34894 PyObject * obj1 = 0 ;
34895 char * kwnames[] = {
34896 (char *) "self",(char *) "rect", NULL
34897 };
34898
34899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34901 if (!SWIG_IsOK(res1)) {
34902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34903 }
34904 arg1 = reinterpret_cast< wxWindow * >(argp1);
34905 {
34906 arg2 = &temp2;
34907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34908 }
34909 {
34910 PyThreadState* __tstate = wxPyBeginAllowThreads();
34911 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 {
34916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34917 }
34918 return resultobj;
34919 fail:
34920 return NULL;
34921 }
34922
34923
34924 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34925 PyObject *resultobj = 0;
34926 wxWindow *arg1 = (wxWindow *) 0 ;
34927 SwigValueWrapper<wxVisualAttributes > result;
34928 void *argp1 = 0 ;
34929 int res1 = 0 ;
34930 PyObject *swig_obj[1] ;
34931
34932 if (!args) SWIG_fail;
34933 swig_obj[0] = args;
34934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34937 }
34938 arg1 = reinterpret_cast< wxWindow * >(argp1);
34939 {
34940 PyThreadState* __tstate = wxPyBeginAllowThreads();
34941 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34946 return resultobj;
34947 fail:
34948 return NULL;
34949 }
34950
34951
34952 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34953 PyObject *resultobj = 0;
34954 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34955 SwigValueWrapper<wxVisualAttributes > result;
34956 int val1 ;
34957 int ecode1 = 0 ;
34958 PyObject * obj0 = 0 ;
34959 char * kwnames[] = {
34960 (char *) "variant", NULL
34961 };
34962
34963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34964 if (obj0) {
34965 ecode1 = SWIG_AsVal_int(obj0, &val1);
34966 if (!SWIG_IsOK(ecode1)) {
34967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34968 }
34969 arg1 = static_cast< wxWindowVariant >(val1);
34970 }
34971 {
34972 if (!wxPyCheckForApp()) SWIG_fail;
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 result = wxWindow::GetClassDefaultAttributes(arg1);
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34986 PyObject *resultobj = 0;
34987 wxWindow *arg1 = (wxWindow *) 0 ;
34988 wxColour *arg2 = 0 ;
34989 bool result;
34990 void *argp1 = 0 ;
34991 int res1 = 0 ;
34992 wxColour temp2 ;
34993 PyObject * obj0 = 0 ;
34994 PyObject * obj1 = 0 ;
34995 char * kwnames[] = {
34996 (char *) "self",(char *) "colour", NULL
34997 };
34998
34999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35001 if (!SWIG_IsOK(res1)) {
35002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35003 }
35004 arg1 = reinterpret_cast< wxWindow * >(argp1);
35005 {
35006 arg2 = &temp2;
35007 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35008 }
35009 {
35010 PyThreadState* __tstate = wxPyBeginAllowThreads();
35011 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35012 wxPyEndAllowThreads(__tstate);
35013 if (PyErr_Occurred()) SWIG_fail;
35014 }
35015 {
35016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35017 }
35018 return resultobj;
35019 fail:
35020 return NULL;
35021 }
35022
35023
35024 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35025 PyObject *resultobj = 0;
35026 wxWindow *arg1 = (wxWindow *) 0 ;
35027 wxColour *arg2 = 0 ;
35028 void *argp1 = 0 ;
35029 int res1 = 0 ;
35030 wxColour temp2 ;
35031 PyObject * obj0 = 0 ;
35032 PyObject * obj1 = 0 ;
35033 char * kwnames[] = {
35034 (char *) "self",(char *) "colour", NULL
35035 };
35036
35037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35039 if (!SWIG_IsOK(res1)) {
35040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35041 }
35042 arg1 = reinterpret_cast< wxWindow * >(argp1);
35043 {
35044 arg2 = &temp2;
35045 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35046 }
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 resultobj = SWIG_Py_Void();
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxWindow *arg1 = (wxWindow *) 0 ;
35063 wxColour *arg2 = 0 ;
35064 bool result;
35065 void *argp1 = 0 ;
35066 int res1 = 0 ;
35067 wxColour temp2 ;
35068 PyObject * obj0 = 0 ;
35069 PyObject * obj1 = 0 ;
35070 char * kwnames[] = {
35071 (char *) "self",(char *) "colour", NULL
35072 };
35073
35074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35076 if (!SWIG_IsOK(res1)) {
35077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35078 }
35079 arg1 = reinterpret_cast< wxWindow * >(argp1);
35080 {
35081 arg2 = &temp2;
35082 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35083 }
35084 {
35085 PyThreadState* __tstate = wxPyBeginAllowThreads();
35086 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35087 wxPyEndAllowThreads(__tstate);
35088 if (PyErr_Occurred()) SWIG_fail;
35089 }
35090 {
35091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35092 }
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35100 PyObject *resultobj = 0;
35101 wxWindow *arg1 = (wxWindow *) 0 ;
35102 wxColour *arg2 = 0 ;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 wxColour temp2 ;
35106 PyObject * obj0 = 0 ;
35107 PyObject * obj1 = 0 ;
35108 char * kwnames[] = {
35109 (char *) "self",(char *) "colour", NULL
35110 };
35111
35112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35116 }
35117 arg1 = reinterpret_cast< wxWindow * >(argp1);
35118 {
35119 arg2 = &temp2;
35120 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35121 }
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 resultobj = SWIG_Py_Void();
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxWindow *arg1 = (wxWindow *) 0 ;
35138 wxColour result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 PyObject *swig_obj[1] ;
35142
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 wxColour result;
35167 void *argp1 = 0 ;
35168 int res1 = 0 ;
35169 PyObject *swig_obj[1] ;
35170
35171 if (!args) SWIG_fail;
35172 swig_obj[0] = args;
35173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35174 if (!SWIG_IsOK(res1)) {
35175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35176 }
35177 arg1 = reinterpret_cast< wxWindow * >(argp1);
35178 {
35179 PyThreadState* __tstate = wxPyBeginAllowThreads();
35180 result = ((wxWindow const *)arg1)->GetForegroundColour();
35181 wxPyEndAllowThreads(__tstate);
35182 if (PyErr_Occurred()) SWIG_fail;
35183 }
35184 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35185 return resultobj;
35186 fail:
35187 return NULL;
35188 }
35189
35190
35191 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35192 PyObject *resultobj = 0;
35193 wxWindow *arg1 = (wxWindow *) 0 ;
35194 bool result;
35195 void *argp1 = 0 ;
35196 int res1 = 0 ;
35197 PyObject *swig_obj[1] ;
35198
35199 if (!args) SWIG_fail;
35200 swig_obj[0] = args;
35201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35202 if (!SWIG_IsOK(res1)) {
35203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35204 }
35205 arg1 = reinterpret_cast< wxWindow * >(argp1);
35206 {
35207 PyThreadState* __tstate = wxPyBeginAllowThreads();
35208 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 {
35213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35214 }
35215 return resultobj;
35216 fail:
35217 return NULL;
35218 }
35219
35220
35221 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35222 PyObject *resultobj = 0;
35223 wxWindow *arg1 = (wxWindow *) 0 ;
35224 bool result;
35225 void *argp1 = 0 ;
35226 int res1 = 0 ;
35227 PyObject *swig_obj[1] ;
35228
35229 if (!args) SWIG_fail;
35230 swig_obj[0] = args;
35231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35232 if (!SWIG_IsOK(res1)) {
35233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35234 }
35235 arg1 = reinterpret_cast< wxWindow * >(argp1);
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35239 wxPyEndAllowThreads(__tstate);
35240 if (PyErr_Occurred()) SWIG_fail;
35241 }
35242 {
35243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35244 }
35245 return resultobj;
35246 fail:
35247 return NULL;
35248 }
35249
35250
35251 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35252 PyObject *resultobj = 0;
35253 wxWindow *arg1 = (wxWindow *) 0 ;
35254 wxBackgroundStyle arg2 ;
35255 bool result;
35256 void *argp1 = 0 ;
35257 int res1 = 0 ;
35258 int val2 ;
35259 int ecode2 = 0 ;
35260 PyObject * obj0 = 0 ;
35261 PyObject * obj1 = 0 ;
35262 char * kwnames[] = {
35263 (char *) "self",(char *) "style", NULL
35264 };
35265
35266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35268 if (!SWIG_IsOK(res1)) {
35269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35270 }
35271 arg1 = reinterpret_cast< wxWindow * >(argp1);
35272 ecode2 = SWIG_AsVal_int(obj1, &val2);
35273 if (!SWIG_IsOK(ecode2)) {
35274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35275 }
35276 arg2 = static_cast< wxBackgroundStyle >(val2);
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 {
35284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35285 }
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35293 PyObject *resultobj = 0;
35294 wxWindow *arg1 = (wxWindow *) 0 ;
35295 wxBackgroundStyle result;
35296 void *argp1 = 0 ;
35297 int res1 = 0 ;
35298 PyObject *swig_obj[1] ;
35299
35300 if (!args) SWIG_fail;
35301 swig_obj[0] = args;
35302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 {
35308 PyThreadState* __tstate = wxPyBeginAllowThreads();
35309 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35310 wxPyEndAllowThreads(__tstate);
35311 if (PyErr_Occurred()) SWIG_fail;
35312 }
35313 resultobj = SWIG_From_int(static_cast< int >(result));
35314 return resultobj;
35315 fail:
35316 return NULL;
35317 }
35318
35319
35320 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35321 PyObject *resultobj = 0;
35322 wxWindow *arg1 = (wxWindow *) 0 ;
35323 bool result;
35324 void *argp1 = 0 ;
35325 int res1 = 0 ;
35326 PyObject *swig_obj[1] ;
35327
35328 if (!args) SWIG_fail;
35329 swig_obj[0] = args;
35330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35331 if (!SWIG_IsOK(res1)) {
35332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35333 }
35334 arg1 = reinterpret_cast< wxWindow * >(argp1);
35335 {
35336 PyThreadState* __tstate = wxPyBeginAllowThreads();
35337 result = (bool)(arg1)->HasTransparentBackground();
35338 wxPyEndAllowThreads(__tstate);
35339 if (PyErr_Occurred()) SWIG_fail;
35340 }
35341 {
35342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35343 }
35344 return resultobj;
35345 fail:
35346 return NULL;
35347 }
35348
35349
35350 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35351 PyObject *resultobj = 0;
35352 wxWindow *arg1 = (wxWindow *) 0 ;
35353 wxCursor *arg2 = 0 ;
35354 bool result;
35355 void *argp1 = 0 ;
35356 int res1 = 0 ;
35357 void *argp2 = 0 ;
35358 int res2 = 0 ;
35359 PyObject * obj0 = 0 ;
35360 PyObject * obj1 = 0 ;
35361 char * kwnames[] = {
35362 (char *) "self",(char *) "cursor", NULL
35363 };
35364
35365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35372 if (!SWIG_IsOK(res2)) {
35373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35374 }
35375 if (!argp2) {
35376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35377 }
35378 arg2 = reinterpret_cast< wxCursor * >(argp2);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 {
35386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35387 }
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35395 PyObject *resultobj = 0;
35396 wxWindow *arg1 = (wxWindow *) 0 ;
35397 wxCursor result;
35398 void *argp1 = 0 ;
35399 int res1 = 0 ;
35400 PyObject *swig_obj[1] ;
35401
35402 if (!args) SWIG_fail;
35403 swig_obj[0] = args;
35404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35405 if (!SWIG_IsOK(res1)) {
35406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35407 }
35408 arg1 = reinterpret_cast< wxWindow * >(argp1);
35409 {
35410 PyThreadState* __tstate = wxPyBeginAllowThreads();
35411 result = (arg1)->GetCursor();
35412 wxPyEndAllowThreads(__tstate);
35413 if (PyErr_Occurred()) SWIG_fail;
35414 }
35415 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35423 PyObject *resultobj = 0;
35424 wxWindow *arg1 = (wxWindow *) 0 ;
35425 wxFont *arg2 = 0 ;
35426 bool result;
35427 void *argp1 = 0 ;
35428 int res1 = 0 ;
35429 void *argp2 = 0 ;
35430 int res2 = 0 ;
35431 PyObject * obj0 = 0 ;
35432 PyObject * obj1 = 0 ;
35433 char * kwnames[] = {
35434 (char *) "self",(char *) "font", NULL
35435 };
35436
35437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35439 if (!SWIG_IsOK(res1)) {
35440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35441 }
35442 arg1 = reinterpret_cast< wxWindow * >(argp1);
35443 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35444 if (!SWIG_IsOK(res2)) {
35445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35446 }
35447 if (!argp2) {
35448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35449 }
35450 arg2 = reinterpret_cast< wxFont * >(argp2);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 {
35458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35459 }
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj = 0;
35468 wxWindow *arg1 = (wxWindow *) 0 ;
35469 wxFont *arg2 = 0 ;
35470 void *argp1 = 0 ;
35471 int res1 = 0 ;
35472 void *argp2 = 0 ;
35473 int res2 = 0 ;
35474 PyObject * obj0 = 0 ;
35475 PyObject * obj1 = 0 ;
35476 char * kwnames[] = {
35477 (char *) "self",(char *) "font", NULL
35478 };
35479
35480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35484 }
35485 arg1 = reinterpret_cast< wxWindow * >(argp1);
35486 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35487 if (!SWIG_IsOK(res2)) {
35488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35489 }
35490 if (!argp2) {
35491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35492 }
35493 arg2 = reinterpret_cast< wxFont * >(argp2);
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 (arg1)->SetOwnFont((wxFont const &)*arg2);
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 resultobj = SWIG_Py_Void();
35501 return resultobj;
35502 fail:
35503 return NULL;
35504 }
35505
35506
35507 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35508 PyObject *resultobj = 0;
35509 wxWindow *arg1 = (wxWindow *) 0 ;
35510 wxFont result;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 PyObject *swig_obj[1] ;
35514
35515 if (!args) SWIG_fail;
35516 swig_obj[0] = args;
35517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35518 if (!SWIG_IsOK(res1)) {
35519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35520 }
35521 arg1 = reinterpret_cast< wxWindow * >(argp1);
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = (arg1)->GetFont();
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35529 return resultobj;
35530 fail:
35531 return NULL;
35532 }
35533
35534
35535 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35536 PyObject *resultobj = 0;
35537 wxWindow *arg1 = (wxWindow *) 0 ;
35538 wxCaret *arg2 = (wxCaret *) 0 ;
35539 void *argp1 = 0 ;
35540 int res1 = 0 ;
35541 int res2 = 0 ;
35542 PyObject * obj0 = 0 ;
35543 PyObject * obj1 = 0 ;
35544 char * kwnames[] = {
35545 (char *) "self",(char *) "caret", NULL
35546 };
35547
35548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35550 if (!SWIG_IsOK(res1)) {
35551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35552 }
35553 arg1 = reinterpret_cast< wxWindow * >(argp1);
35554 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35555 if (!SWIG_IsOK(res2)) {
35556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35557 }
35558 {
35559 PyThreadState* __tstate = wxPyBeginAllowThreads();
35560 (arg1)->SetCaret(arg2);
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 resultobj = SWIG_Py_Void();
35565 return resultobj;
35566 fail:
35567 return NULL;
35568 }
35569
35570
35571 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35572 PyObject *resultobj = 0;
35573 wxWindow *arg1 = (wxWindow *) 0 ;
35574 wxCaret *result = 0 ;
35575 void *argp1 = 0 ;
35576 int res1 = 0 ;
35577 PyObject *swig_obj[1] ;
35578
35579 if (!args) SWIG_fail;
35580 swig_obj[0] = args;
35581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35582 if (!SWIG_IsOK(res1)) {
35583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35584 }
35585 arg1 = reinterpret_cast< wxWindow * >(argp1);
35586 {
35587 PyThreadState* __tstate = wxPyBeginAllowThreads();
35588 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35589 wxPyEndAllowThreads(__tstate);
35590 if (PyErr_Occurred()) SWIG_fail;
35591 }
35592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35593 return resultobj;
35594 fail:
35595 return NULL;
35596 }
35597
35598
35599 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35600 PyObject *resultobj = 0;
35601 wxWindow *arg1 = (wxWindow *) 0 ;
35602 int result;
35603 void *argp1 = 0 ;
35604 int res1 = 0 ;
35605 PyObject *swig_obj[1] ;
35606
35607 if (!args) SWIG_fail;
35608 swig_obj[0] = args;
35609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35610 if (!SWIG_IsOK(res1)) {
35611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35612 }
35613 arg1 = reinterpret_cast< wxWindow * >(argp1);
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 resultobj = SWIG_From_int(static_cast< int >(result));
35621 return resultobj;
35622 fail:
35623 return NULL;
35624 }
35625
35626
35627 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35628 PyObject *resultobj = 0;
35629 wxWindow *arg1 = (wxWindow *) 0 ;
35630 int result;
35631 void *argp1 = 0 ;
35632 int res1 = 0 ;
35633 PyObject *swig_obj[1] ;
35634
35635 if (!args) SWIG_fail;
35636 swig_obj[0] = args;
35637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35638 if (!SWIG_IsOK(res1)) {
35639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35640 }
35641 arg1 = reinterpret_cast< wxWindow * >(argp1);
35642 {
35643 PyThreadState* __tstate = wxPyBeginAllowThreads();
35644 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35645 wxPyEndAllowThreads(__tstate);
35646 if (PyErr_Occurred()) SWIG_fail;
35647 }
35648 resultobj = SWIG_From_int(static_cast< int >(result));
35649 return resultobj;
35650 fail:
35651 return NULL;
35652 }
35653
35654
35655 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35656 PyObject *resultobj = 0;
35657 wxWindow *arg1 = (wxWindow *) 0 ;
35658 wxString *arg2 = 0 ;
35659 int *arg3 = (int *) 0 ;
35660 int *arg4 = (int *) 0 ;
35661 void *argp1 = 0 ;
35662 int res1 = 0 ;
35663 bool temp2 = false ;
35664 int temp3 ;
35665 int res3 = SWIG_TMPOBJ ;
35666 int temp4 ;
35667 int res4 = SWIG_TMPOBJ ;
35668 PyObject * obj0 = 0 ;
35669 PyObject * obj1 = 0 ;
35670 char * kwnames[] = {
35671 (char *) "self",(char *) "string", NULL
35672 };
35673
35674 arg3 = &temp3;
35675 arg4 = &temp4;
35676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35678 if (!SWIG_IsOK(res1)) {
35679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35680 }
35681 arg1 = reinterpret_cast< wxWindow * >(argp1);
35682 {
35683 arg2 = wxString_in_helper(obj1);
35684 if (arg2 == NULL) SWIG_fail;
35685 temp2 = true;
35686 }
35687 {
35688 PyThreadState* __tstate = wxPyBeginAllowThreads();
35689 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35690 wxPyEndAllowThreads(__tstate);
35691 if (PyErr_Occurred()) SWIG_fail;
35692 }
35693 resultobj = SWIG_Py_Void();
35694 if (SWIG_IsTmpObj(res3)) {
35695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35696 } else {
35697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35699 }
35700 if (SWIG_IsTmpObj(res4)) {
35701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35702 } else {
35703 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35705 }
35706 {
35707 if (temp2)
35708 delete arg2;
35709 }
35710 return resultobj;
35711 fail:
35712 {
35713 if (temp2)
35714 delete arg2;
35715 }
35716 return NULL;
35717 }
35718
35719
35720 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35721 PyObject *resultobj = 0;
35722 wxWindow *arg1 = (wxWindow *) 0 ;
35723 wxString *arg2 = 0 ;
35724 int *arg3 = (int *) 0 ;
35725 int *arg4 = (int *) 0 ;
35726 int *arg5 = (int *) 0 ;
35727 int *arg6 = (int *) 0 ;
35728 wxFont *arg7 = (wxFont *) NULL ;
35729 void *argp1 = 0 ;
35730 int res1 = 0 ;
35731 bool temp2 = false ;
35732 int temp3 ;
35733 int res3 = SWIG_TMPOBJ ;
35734 int temp4 ;
35735 int res4 = SWIG_TMPOBJ ;
35736 int temp5 ;
35737 int res5 = SWIG_TMPOBJ ;
35738 int temp6 ;
35739 int res6 = SWIG_TMPOBJ ;
35740 void *argp7 = 0 ;
35741 int res7 = 0 ;
35742 PyObject * obj0 = 0 ;
35743 PyObject * obj1 = 0 ;
35744 PyObject * obj2 = 0 ;
35745 char * kwnames[] = {
35746 (char *) "self",(char *) "string",(char *) "font", NULL
35747 };
35748
35749 arg3 = &temp3;
35750 arg4 = &temp4;
35751 arg5 = &temp5;
35752 arg6 = &temp6;
35753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35755 if (!SWIG_IsOK(res1)) {
35756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35757 }
35758 arg1 = reinterpret_cast< wxWindow * >(argp1);
35759 {
35760 arg2 = wxString_in_helper(obj1);
35761 if (arg2 == NULL) SWIG_fail;
35762 temp2 = true;
35763 }
35764 if (obj2) {
35765 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35766 if (!SWIG_IsOK(res7)) {
35767 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35768 }
35769 arg7 = reinterpret_cast< wxFont * >(argp7);
35770 }
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35774 wxPyEndAllowThreads(__tstate);
35775 if (PyErr_Occurred()) SWIG_fail;
35776 }
35777 resultobj = SWIG_Py_Void();
35778 if (SWIG_IsTmpObj(res3)) {
35779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35780 } else {
35781 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35783 }
35784 if (SWIG_IsTmpObj(res4)) {
35785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35786 } else {
35787 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35789 }
35790 if (SWIG_IsTmpObj(res5)) {
35791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35792 } else {
35793 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35795 }
35796 if (SWIG_IsTmpObj(res6)) {
35797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35798 } else {
35799 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35801 }
35802 {
35803 if (temp2)
35804 delete arg2;
35805 }
35806 return resultobj;
35807 fail:
35808 {
35809 if (temp2)
35810 delete arg2;
35811 }
35812 return NULL;
35813 }
35814
35815
35816 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35817 PyObject *resultobj = 0;
35818 wxWindow *arg1 = (wxWindow *) 0 ;
35819 int *arg2 = (int *) 0 ;
35820 int *arg3 = (int *) 0 ;
35821 void *argp1 = 0 ;
35822 int res1 = 0 ;
35823 int temp2 ;
35824 int res2 = 0 ;
35825 int temp3 ;
35826 int res3 = 0 ;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 PyObject * obj2 = 0 ;
35830 char * kwnames[] = {
35831 (char *) "self",(char *) "x",(char *) "y", NULL
35832 };
35833
35834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35836 if (!SWIG_IsOK(res1)) {
35837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35838 }
35839 arg1 = reinterpret_cast< wxWindow * >(argp1);
35840 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35841 int val;
35842 int ecode = SWIG_AsVal_int(obj1, &val);
35843 if (!SWIG_IsOK(ecode)) {
35844 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35845 }
35846 temp2 = static_cast< int >(val);
35847 arg2 = &temp2;
35848 res2 = SWIG_AddTmpMask(ecode);
35849 }
35850 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35851 int val;
35852 int ecode = SWIG_AsVal_int(obj2, &val);
35853 if (!SWIG_IsOK(ecode)) {
35854 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35855 }
35856 temp3 = static_cast< int >(val);
35857 arg3 = &temp3;
35858 res3 = SWIG_AddTmpMask(ecode);
35859 }
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 resultobj = SWIG_Py_Void();
35867 if (SWIG_IsTmpObj(res2)) {
35868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35869 } else {
35870 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35872 }
35873 if (SWIG_IsTmpObj(res3)) {
35874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35875 } else {
35876 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35878 }
35879 return resultobj;
35880 fail:
35881 return NULL;
35882 }
35883
35884
35885 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35886 PyObject *resultobj = 0;
35887 wxWindow *arg1 = (wxWindow *) 0 ;
35888 int *arg2 = (int *) 0 ;
35889 int *arg3 = (int *) 0 ;
35890 void *argp1 = 0 ;
35891 int res1 = 0 ;
35892 int temp2 ;
35893 int res2 = 0 ;
35894 int temp3 ;
35895 int res3 = 0 ;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 PyObject * obj2 = 0 ;
35899 char * kwnames[] = {
35900 (char *) "self",(char *) "x",(char *) "y", NULL
35901 };
35902
35903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35905 if (!SWIG_IsOK(res1)) {
35906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35907 }
35908 arg1 = reinterpret_cast< wxWindow * >(argp1);
35909 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35910 int val;
35911 int ecode = SWIG_AsVal_int(obj1, &val);
35912 if (!SWIG_IsOK(ecode)) {
35913 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35914 }
35915 temp2 = static_cast< int >(val);
35916 arg2 = &temp2;
35917 res2 = SWIG_AddTmpMask(ecode);
35918 }
35919 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35920 int val;
35921 int ecode = SWIG_AsVal_int(obj2, &val);
35922 if (!SWIG_IsOK(ecode)) {
35923 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35924 }
35925 temp3 = static_cast< int >(val);
35926 arg3 = &temp3;
35927 res3 = SWIG_AddTmpMask(ecode);
35928 }
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35932 wxPyEndAllowThreads(__tstate);
35933 if (PyErr_Occurred()) SWIG_fail;
35934 }
35935 resultobj = SWIG_Py_Void();
35936 if (SWIG_IsTmpObj(res2)) {
35937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35938 } else {
35939 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35941 }
35942 if (SWIG_IsTmpObj(res3)) {
35943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35944 } else {
35945 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35947 }
35948 return resultobj;
35949 fail:
35950 return NULL;
35951 }
35952
35953
35954 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35955 PyObject *resultobj = 0;
35956 wxWindow *arg1 = (wxWindow *) 0 ;
35957 wxPoint *arg2 = 0 ;
35958 wxPoint result;
35959 void *argp1 = 0 ;
35960 int res1 = 0 ;
35961 wxPoint temp2 ;
35962 PyObject * obj0 = 0 ;
35963 PyObject * obj1 = 0 ;
35964 char * kwnames[] = {
35965 (char *) "self",(char *) "pt", NULL
35966 };
35967
35968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35970 if (!SWIG_IsOK(res1)) {
35971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35972 }
35973 arg1 = reinterpret_cast< wxWindow * >(argp1);
35974 {
35975 arg2 = &temp2;
35976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35977 }
35978 {
35979 PyThreadState* __tstate = wxPyBeginAllowThreads();
35980 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35985 return resultobj;
35986 fail:
35987 return NULL;
35988 }
35989
35990
35991 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35992 PyObject *resultobj = 0;
35993 wxWindow *arg1 = (wxWindow *) 0 ;
35994 wxPoint *arg2 = 0 ;
35995 wxPoint result;
35996 void *argp1 = 0 ;
35997 int res1 = 0 ;
35998 wxPoint temp2 ;
35999 PyObject * obj0 = 0 ;
36000 PyObject * obj1 = 0 ;
36001 char * kwnames[] = {
36002 (char *) "self",(char *) "pt", NULL
36003 };
36004
36005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36009 }
36010 arg1 = reinterpret_cast< wxWindow * >(argp1);
36011 {
36012 arg2 = &temp2;
36013 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36014 }
36015 {
36016 PyThreadState* __tstate = wxPyBeginAllowThreads();
36017 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36018 wxPyEndAllowThreads(__tstate);
36019 if (PyErr_Occurred()) SWIG_fail;
36020 }
36021 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36022 return resultobj;
36023 fail:
36024 return NULL;
36025 }
36026
36027
36028 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36029 PyObject *resultobj = 0;
36030 wxWindow *arg1 = (wxWindow *) 0 ;
36031 int arg2 ;
36032 int arg3 ;
36033 wxHitTest result;
36034 void *argp1 = 0 ;
36035 int res1 = 0 ;
36036 int val2 ;
36037 int ecode2 = 0 ;
36038 int val3 ;
36039 int ecode3 = 0 ;
36040 PyObject * obj0 = 0 ;
36041 PyObject * obj1 = 0 ;
36042 PyObject * obj2 = 0 ;
36043 char * kwnames[] = {
36044 (char *) "self",(char *) "x",(char *) "y", NULL
36045 };
36046
36047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36049 if (!SWIG_IsOK(res1)) {
36050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36051 }
36052 arg1 = reinterpret_cast< wxWindow * >(argp1);
36053 ecode2 = SWIG_AsVal_int(obj1, &val2);
36054 if (!SWIG_IsOK(ecode2)) {
36055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36056 }
36057 arg2 = static_cast< int >(val2);
36058 ecode3 = SWIG_AsVal_int(obj2, &val3);
36059 if (!SWIG_IsOK(ecode3)) {
36060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36061 }
36062 arg3 = static_cast< int >(val3);
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36066 wxPyEndAllowThreads(__tstate);
36067 if (PyErr_Occurred()) SWIG_fail;
36068 }
36069 resultobj = SWIG_From_int(static_cast< int >(result));
36070 return resultobj;
36071 fail:
36072 return NULL;
36073 }
36074
36075
36076 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36077 PyObject *resultobj = 0;
36078 wxWindow *arg1 = (wxWindow *) 0 ;
36079 wxPoint *arg2 = 0 ;
36080 wxHitTest result;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 wxPoint temp2 ;
36084 PyObject * obj0 = 0 ;
36085 PyObject * obj1 = 0 ;
36086 char * kwnames[] = {
36087 (char *) "self",(char *) "pt", NULL
36088 };
36089
36090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36092 if (!SWIG_IsOK(res1)) {
36093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36094 }
36095 arg1 = reinterpret_cast< wxWindow * >(argp1);
36096 {
36097 arg2 = &temp2;
36098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36099 }
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 resultobj = SWIG_From_int(static_cast< int >(result));
36107 return resultobj;
36108 fail:
36109 return NULL;
36110 }
36111
36112
36113 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36114 PyObject *resultobj = 0;
36115 wxWindow *arg1 = (wxWindow *) 0 ;
36116 long arg2 ;
36117 wxBorder result;
36118 void *argp1 = 0 ;
36119 int res1 = 0 ;
36120 long val2 ;
36121 int ecode2 = 0 ;
36122
36123 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36125 if (!SWIG_IsOK(res1)) {
36126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36127 }
36128 arg1 = reinterpret_cast< wxWindow * >(argp1);
36129 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36130 if (!SWIG_IsOK(ecode2)) {
36131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36132 }
36133 arg2 = static_cast< long >(val2);
36134 {
36135 PyThreadState* __tstate = wxPyBeginAllowThreads();
36136 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 resultobj = SWIG_From_int(static_cast< int >(result));
36141 return resultobj;
36142 fail:
36143 return NULL;
36144 }
36145
36146
36147 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36148 PyObject *resultobj = 0;
36149 wxWindow *arg1 = (wxWindow *) 0 ;
36150 wxBorder result;
36151 void *argp1 = 0 ;
36152 int res1 = 0 ;
36153
36154 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36156 if (!SWIG_IsOK(res1)) {
36157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36158 }
36159 arg1 = reinterpret_cast< wxWindow * >(argp1);
36160 {
36161 PyThreadState* __tstate = wxPyBeginAllowThreads();
36162 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36163 wxPyEndAllowThreads(__tstate);
36164 if (PyErr_Occurred()) SWIG_fail;
36165 }
36166 resultobj = SWIG_From_int(static_cast< int >(result));
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36174 int argc;
36175 PyObject *argv[3];
36176
36177 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36178 --argc;
36179 if (argc == 1) {
36180 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36181 }
36182 if (argc == 2) {
36183 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36184 }
36185
36186 fail:
36187 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj = 0;
36194 wxWindow *arg1 = (wxWindow *) 0 ;
36195 long arg2 = (long) wxUPDATE_UI_NONE ;
36196 void *argp1 = 0 ;
36197 int res1 = 0 ;
36198 long val2 ;
36199 int ecode2 = 0 ;
36200 PyObject * obj0 = 0 ;
36201 PyObject * obj1 = 0 ;
36202 char * kwnames[] = {
36203 (char *) "self",(char *) "flags", NULL
36204 };
36205
36206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36208 if (!SWIG_IsOK(res1)) {
36209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36210 }
36211 arg1 = reinterpret_cast< wxWindow * >(argp1);
36212 if (obj1) {
36213 ecode2 = SWIG_AsVal_long(obj1, &val2);
36214 if (!SWIG_IsOK(ecode2)) {
36215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36216 }
36217 arg2 = static_cast< long >(val2);
36218 }
36219 {
36220 PyThreadState* __tstate = wxPyBeginAllowThreads();
36221 (arg1)->UpdateWindowUI(arg2);
36222 wxPyEndAllowThreads(__tstate);
36223 if (PyErr_Occurred()) SWIG_fail;
36224 }
36225 resultobj = SWIG_Py_Void();
36226 return resultobj;
36227 fail:
36228 return NULL;
36229 }
36230
36231
36232 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36233 PyObject *resultobj = 0;
36234 wxWindow *arg1 = (wxWindow *) 0 ;
36235 wxMenu *arg2 = (wxMenu *) 0 ;
36236 int arg3 = (int) -1 ;
36237 int arg4 = (int) -1 ;
36238 bool result;
36239 void *argp1 = 0 ;
36240 int res1 = 0 ;
36241 void *argp2 = 0 ;
36242 int res2 = 0 ;
36243 int val3 ;
36244 int ecode3 = 0 ;
36245 int val4 ;
36246 int ecode4 = 0 ;
36247 PyObject * obj0 = 0 ;
36248 PyObject * obj1 = 0 ;
36249 PyObject * obj2 = 0 ;
36250 PyObject * obj3 = 0 ;
36251 char * kwnames[] = {
36252 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36253 };
36254
36255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36262 if (!SWIG_IsOK(res2)) {
36263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36264 }
36265 arg2 = reinterpret_cast< wxMenu * >(argp2);
36266 if (obj2) {
36267 ecode3 = SWIG_AsVal_int(obj2, &val3);
36268 if (!SWIG_IsOK(ecode3)) {
36269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36270 }
36271 arg3 = static_cast< int >(val3);
36272 }
36273 if (obj3) {
36274 ecode4 = SWIG_AsVal_int(obj3, &val4);
36275 if (!SWIG_IsOK(ecode4)) {
36276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36277 }
36278 arg4 = static_cast< int >(val4);
36279 }
36280 {
36281 PyThreadState* __tstate = wxPyBeginAllowThreads();
36282 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36283 wxPyEndAllowThreads(__tstate);
36284 if (PyErr_Occurred()) SWIG_fail;
36285 }
36286 {
36287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36288 }
36289 return resultobj;
36290 fail:
36291 return NULL;
36292 }
36293
36294
36295 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36296 PyObject *resultobj = 0;
36297 wxWindow *arg1 = (wxWindow *) 0 ;
36298 wxMenu *arg2 = (wxMenu *) 0 ;
36299 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36300 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36301 bool result;
36302 void *argp1 = 0 ;
36303 int res1 = 0 ;
36304 void *argp2 = 0 ;
36305 int res2 = 0 ;
36306 wxPoint temp3 ;
36307 PyObject * obj0 = 0 ;
36308 PyObject * obj1 = 0 ;
36309 PyObject * obj2 = 0 ;
36310 char * kwnames[] = {
36311 (char *) "self",(char *) "menu",(char *) "pos", NULL
36312 };
36313
36314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36318 }
36319 arg1 = reinterpret_cast< wxWindow * >(argp1);
36320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36321 if (!SWIG_IsOK(res2)) {
36322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36323 }
36324 arg2 = reinterpret_cast< wxMenu * >(argp2);
36325 if (obj2) {
36326 {
36327 arg3 = &temp3;
36328 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36329 }
36330 }
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36334 wxPyEndAllowThreads(__tstate);
36335 if (PyErr_Occurred()) SWIG_fail;
36336 }
36337 {
36338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36339 }
36340 return resultobj;
36341 fail:
36342 return NULL;
36343 }
36344
36345
36346 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36347 PyObject *resultobj = 0;
36348 wxWindow *arg1 = (wxWindow *) 0 ;
36349 bool result;
36350 void *argp1 = 0 ;
36351 int res1 = 0 ;
36352 PyObject *swig_obj[1] ;
36353
36354 if (!args) SWIG_fail;
36355 swig_obj[0] = args;
36356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 {
36368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36369 }
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36377 PyObject *resultobj = 0;
36378 wxWindow *arg1 = (wxWindow *) 0 ;
36379 long result;
36380 void *argp1 = 0 ;
36381 int res1 = 0 ;
36382 PyObject *swig_obj[1] ;
36383
36384 if (!args) SWIG_fail;
36385 swig_obj[0] = args;
36386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36387 if (!SWIG_IsOK(res1)) {
36388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36389 }
36390 arg1 = reinterpret_cast< wxWindow * >(argp1);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (long)wxWindow_GetHandle(arg1);
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 resultobj = SWIG_From_long(static_cast< long >(result));
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 long arg2 ;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 long val2 ;
36411 int ecode2 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "handle", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 ecode2 = SWIG_AsVal_long(obj1, &val2);
36425 if (!SWIG_IsOK(ecode2)) {
36426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36427 }
36428 arg2 = static_cast< long >(val2);
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 wxWindow_AssociateHandle(arg1,arg2);
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 resultobj = SWIG_Py_Void();
36436 return resultobj;
36437 fail:
36438 return NULL;
36439 }
36440
36441
36442 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36443 PyObject *resultobj = 0;
36444 wxWindow *arg1 = (wxWindow *) 0 ;
36445 void *argp1 = 0 ;
36446 int res1 = 0 ;
36447 PyObject *swig_obj[1] ;
36448
36449 if (!args) SWIG_fail;
36450 swig_obj[0] = args;
36451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36452 if (!SWIG_IsOK(res1)) {
36453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36454 }
36455 arg1 = reinterpret_cast< wxWindow * >(argp1);
36456 {
36457 PyThreadState* __tstate = wxPyBeginAllowThreads();
36458 (arg1)->DissociateHandle();
36459 wxPyEndAllowThreads(__tstate);
36460 if (PyErr_Occurred()) SWIG_fail;
36461 }
36462 resultobj = SWIG_Py_Void();
36463 return resultobj;
36464 fail:
36465 return NULL;
36466 }
36467
36468
36469 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36470 PyObject *resultobj = 0;
36471 wxWindow *arg1 = (wxWindow *) 0 ;
36472 wxPaintEvent *arg2 = 0 ;
36473 void *argp1 = 0 ;
36474 int res1 = 0 ;
36475 void *argp2 = 0 ;
36476 int res2 = 0 ;
36477 PyObject * obj0 = 0 ;
36478 PyObject * obj1 = 0 ;
36479 char * kwnames[] = {
36480 (char *) "self",(char *) "event", NULL
36481 };
36482
36483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36485 if (!SWIG_IsOK(res1)) {
36486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36487 }
36488 arg1 = reinterpret_cast< wxWindow * >(argp1);
36489 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36490 if (!SWIG_IsOK(res2)) {
36491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36492 }
36493 if (!argp2) {
36494 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36495 }
36496 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36497 {
36498 PyThreadState* __tstate = wxPyBeginAllowThreads();
36499 (arg1)->OnPaint(*arg2);
36500 wxPyEndAllowThreads(__tstate);
36501 if (PyErr_Occurred()) SWIG_fail;
36502 }
36503 resultobj = SWIG_Py_Void();
36504 return resultobj;
36505 fail:
36506 return NULL;
36507 }
36508
36509
36510 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36511 PyObject *resultobj = 0;
36512 wxWindow *arg1 = (wxWindow *) 0 ;
36513 int arg2 ;
36514 bool result;
36515 void *argp1 = 0 ;
36516 int res1 = 0 ;
36517 int val2 ;
36518 int ecode2 = 0 ;
36519 PyObject * obj0 = 0 ;
36520 PyObject * obj1 = 0 ;
36521 char * kwnames[] = {
36522 (char *) "self",(char *) "orient", NULL
36523 };
36524
36525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36527 if (!SWIG_IsOK(res1)) {
36528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36529 }
36530 arg1 = reinterpret_cast< wxWindow * >(argp1);
36531 ecode2 = SWIG_AsVal_int(obj1, &val2);
36532 if (!SWIG_IsOK(ecode2)) {
36533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36534 }
36535 arg2 = static_cast< int >(val2);
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36539 wxPyEndAllowThreads(__tstate);
36540 if (PyErr_Occurred()) SWIG_fail;
36541 }
36542 {
36543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36544 }
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36552 PyObject *resultobj = 0;
36553 wxWindow *arg1 = (wxWindow *) 0 ;
36554 int arg2 ;
36555 int arg3 ;
36556 int arg4 ;
36557 int arg5 ;
36558 bool arg6 = (bool) true ;
36559 void *argp1 = 0 ;
36560 int res1 = 0 ;
36561 int val2 ;
36562 int ecode2 = 0 ;
36563 int val3 ;
36564 int ecode3 = 0 ;
36565 int val4 ;
36566 int ecode4 = 0 ;
36567 int val5 ;
36568 int ecode5 = 0 ;
36569 bool val6 ;
36570 int ecode6 = 0 ;
36571 PyObject * obj0 = 0 ;
36572 PyObject * obj1 = 0 ;
36573 PyObject * obj2 = 0 ;
36574 PyObject * obj3 = 0 ;
36575 PyObject * obj4 = 0 ;
36576 PyObject * obj5 = 0 ;
36577 char * kwnames[] = {
36578 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36579 };
36580
36581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36583 if (!SWIG_IsOK(res1)) {
36584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36585 }
36586 arg1 = reinterpret_cast< wxWindow * >(argp1);
36587 ecode2 = SWIG_AsVal_int(obj1, &val2);
36588 if (!SWIG_IsOK(ecode2)) {
36589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36590 }
36591 arg2 = static_cast< int >(val2);
36592 ecode3 = SWIG_AsVal_int(obj2, &val3);
36593 if (!SWIG_IsOK(ecode3)) {
36594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36595 }
36596 arg3 = static_cast< int >(val3);
36597 ecode4 = SWIG_AsVal_int(obj3, &val4);
36598 if (!SWIG_IsOK(ecode4)) {
36599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36600 }
36601 arg4 = static_cast< int >(val4);
36602 ecode5 = SWIG_AsVal_int(obj4, &val5);
36603 if (!SWIG_IsOK(ecode5)) {
36604 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36605 }
36606 arg5 = static_cast< int >(val5);
36607 if (obj5) {
36608 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36609 if (!SWIG_IsOK(ecode6)) {
36610 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36611 }
36612 arg6 = static_cast< bool >(val6);
36613 }
36614 {
36615 PyThreadState* __tstate = wxPyBeginAllowThreads();
36616 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 resultobj = SWIG_Py_Void();
36621 return resultobj;
36622 fail:
36623 return NULL;
36624 }
36625
36626
36627 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36628 PyObject *resultobj = 0;
36629 wxWindow *arg1 = (wxWindow *) 0 ;
36630 int arg2 ;
36631 int arg3 ;
36632 bool arg4 = (bool) true ;
36633 void *argp1 = 0 ;
36634 int res1 = 0 ;
36635 int val2 ;
36636 int ecode2 = 0 ;
36637 int val3 ;
36638 int ecode3 = 0 ;
36639 bool val4 ;
36640 int ecode4 = 0 ;
36641 PyObject * obj0 = 0 ;
36642 PyObject * obj1 = 0 ;
36643 PyObject * obj2 = 0 ;
36644 PyObject * obj3 = 0 ;
36645 char * kwnames[] = {
36646 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36647 };
36648
36649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36651 if (!SWIG_IsOK(res1)) {
36652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36653 }
36654 arg1 = reinterpret_cast< wxWindow * >(argp1);
36655 ecode2 = SWIG_AsVal_int(obj1, &val2);
36656 if (!SWIG_IsOK(ecode2)) {
36657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36658 }
36659 arg2 = static_cast< int >(val2);
36660 ecode3 = SWIG_AsVal_int(obj2, &val3);
36661 if (!SWIG_IsOK(ecode3)) {
36662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36663 }
36664 arg3 = static_cast< int >(val3);
36665 if (obj3) {
36666 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36667 if (!SWIG_IsOK(ecode4)) {
36668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36669 }
36670 arg4 = static_cast< bool >(val4);
36671 }
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 (arg1)->SetScrollPos(arg2,arg3,arg4);
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 resultobj = SWIG_Py_Void();
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36686 PyObject *resultobj = 0;
36687 wxWindow *arg1 = (wxWindow *) 0 ;
36688 int arg2 ;
36689 int result;
36690 void *argp1 = 0 ;
36691 int res1 = 0 ;
36692 int val2 ;
36693 int ecode2 = 0 ;
36694 PyObject * obj0 = 0 ;
36695 PyObject * obj1 = 0 ;
36696 char * kwnames[] = {
36697 (char *) "self",(char *) "orientation", NULL
36698 };
36699
36700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36702 if (!SWIG_IsOK(res1)) {
36703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36704 }
36705 arg1 = reinterpret_cast< wxWindow * >(argp1);
36706 ecode2 = SWIG_AsVal_int(obj1, &val2);
36707 if (!SWIG_IsOK(ecode2)) {
36708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36709 }
36710 arg2 = static_cast< int >(val2);
36711 {
36712 PyThreadState* __tstate = wxPyBeginAllowThreads();
36713 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36714 wxPyEndAllowThreads(__tstate);
36715 if (PyErr_Occurred()) SWIG_fail;
36716 }
36717 resultobj = SWIG_From_int(static_cast< int >(result));
36718 return resultobj;
36719 fail:
36720 return NULL;
36721 }
36722
36723
36724 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36725 PyObject *resultobj = 0;
36726 wxWindow *arg1 = (wxWindow *) 0 ;
36727 int arg2 ;
36728 int result;
36729 void *argp1 = 0 ;
36730 int res1 = 0 ;
36731 int val2 ;
36732 int ecode2 = 0 ;
36733 PyObject * obj0 = 0 ;
36734 PyObject * obj1 = 0 ;
36735 char * kwnames[] = {
36736 (char *) "self",(char *) "orientation", NULL
36737 };
36738
36739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36741 if (!SWIG_IsOK(res1)) {
36742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36743 }
36744 arg1 = reinterpret_cast< wxWindow * >(argp1);
36745 ecode2 = SWIG_AsVal_int(obj1, &val2);
36746 if (!SWIG_IsOK(ecode2)) {
36747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36748 }
36749 arg2 = static_cast< int >(val2);
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36753 wxPyEndAllowThreads(__tstate);
36754 if (PyErr_Occurred()) SWIG_fail;
36755 }
36756 resultobj = SWIG_From_int(static_cast< int >(result));
36757 return resultobj;
36758 fail:
36759 return NULL;
36760 }
36761
36762
36763 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36764 PyObject *resultobj = 0;
36765 wxWindow *arg1 = (wxWindow *) 0 ;
36766 int arg2 ;
36767 int result;
36768 void *argp1 = 0 ;
36769 int res1 = 0 ;
36770 int val2 ;
36771 int ecode2 = 0 ;
36772 PyObject * obj0 = 0 ;
36773 PyObject * obj1 = 0 ;
36774 char * kwnames[] = {
36775 (char *) "self",(char *) "orientation", NULL
36776 };
36777
36778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36780 if (!SWIG_IsOK(res1)) {
36781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36782 }
36783 arg1 = reinterpret_cast< wxWindow * >(argp1);
36784 ecode2 = SWIG_AsVal_int(obj1, &val2);
36785 if (!SWIG_IsOK(ecode2)) {
36786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36787 }
36788 arg2 = static_cast< int >(val2);
36789 {
36790 PyThreadState* __tstate = wxPyBeginAllowThreads();
36791 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36792 wxPyEndAllowThreads(__tstate);
36793 if (PyErr_Occurred()) SWIG_fail;
36794 }
36795 resultobj = SWIG_From_int(static_cast< int >(result));
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 int arg2 ;
36806 int arg3 ;
36807 wxRect *arg4 = (wxRect *) NULL ;
36808 void *argp1 = 0 ;
36809 int res1 = 0 ;
36810 int val2 ;
36811 int ecode2 = 0 ;
36812 int val3 ;
36813 int ecode3 = 0 ;
36814 void *argp4 = 0 ;
36815 int res4 = 0 ;
36816 PyObject * obj0 = 0 ;
36817 PyObject * obj1 = 0 ;
36818 PyObject * obj2 = 0 ;
36819 PyObject * obj3 = 0 ;
36820 char * kwnames[] = {
36821 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36822 };
36823
36824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36826 if (!SWIG_IsOK(res1)) {
36827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36828 }
36829 arg1 = reinterpret_cast< wxWindow * >(argp1);
36830 ecode2 = SWIG_AsVal_int(obj1, &val2);
36831 if (!SWIG_IsOK(ecode2)) {
36832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36833 }
36834 arg2 = static_cast< int >(val2);
36835 ecode3 = SWIG_AsVal_int(obj2, &val3);
36836 if (!SWIG_IsOK(ecode3)) {
36837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36838 }
36839 arg3 = static_cast< int >(val3);
36840 if (obj3) {
36841 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36842 if (!SWIG_IsOK(res4)) {
36843 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36844 }
36845 arg4 = reinterpret_cast< wxRect * >(argp4);
36846 }
36847 {
36848 PyThreadState* __tstate = wxPyBeginAllowThreads();
36849 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36850 wxPyEndAllowThreads(__tstate);
36851 if (PyErr_Occurred()) SWIG_fail;
36852 }
36853 resultobj = SWIG_Py_Void();
36854 return resultobj;
36855 fail:
36856 return NULL;
36857 }
36858
36859
36860 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36861 PyObject *resultobj = 0;
36862 wxWindow *arg1 = (wxWindow *) 0 ;
36863 int arg2 ;
36864 bool result;
36865 void *argp1 = 0 ;
36866 int res1 = 0 ;
36867 int val2 ;
36868 int ecode2 = 0 ;
36869 PyObject * obj0 = 0 ;
36870 PyObject * obj1 = 0 ;
36871 char * kwnames[] = {
36872 (char *) "self",(char *) "lines", NULL
36873 };
36874
36875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36877 if (!SWIG_IsOK(res1)) {
36878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36879 }
36880 arg1 = reinterpret_cast< wxWindow * >(argp1);
36881 ecode2 = SWIG_AsVal_int(obj1, &val2);
36882 if (!SWIG_IsOK(ecode2)) {
36883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36884 }
36885 arg2 = static_cast< int >(val2);
36886 {
36887 PyThreadState* __tstate = wxPyBeginAllowThreads();
36888 result = (bool)(arg1)->ScrollLines(arg2);
36889 wxPyEndAllowThreads(__tstate);
36890 if (PyErr_Occurred()) SWIG_fail;
36891 }
36892 {
36893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36894 }
36895 return resultobj;
36896 fail:
36897 return NULL;
36898 }
36899
36900
36901 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36902 PyObject *resultobj = 0;
36903 wxWindow *arg1 = (wxWindow *) 0 ;
36904 int arg2 ;
36905 bool result;
36906 void *argp1 = 0 ;
36907 int res1 = 0 ;
36908 int val2 ;
36909 int ecode2 = 0 ;
36910 PyObject * obj0 = 0 ;
36911 PyObject * obj1 = 0 ;
36912 char * kwnames[] = {
36913 (char *) "self",(char *) "pages", NULL
36914 };
36915
36916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 ecode2 = SWIG_AsVal_int(obj1, &val2);
36923 if (!SWIG_IsOK(ecode2)) {
36924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36925 }
36926 arg2 = static_cast< int >(val2);
36927 {
36928 PyThreadState* __tstate = wxPyBeginAllowThreads();
36929 result = (bool)(arg1)->ScrollPages(arg2);
36930 wxPyEndAllowThreads(__tstate);
36931 if (PyErr_Occurred()) SWIG_fail;
36932 }
36933 {
36934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36935 }
36936 return resultobj;
36937 fail:
36938 return NULL;
36939 }
36940
36941
36942 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36943 PyObject *resultobj = 0;
36944 wxWindow *arg1 = (wxWindow *) 0 ;
36945 bool result;
36946 void *argp1 = 0 ;
36947 int res1 = 0 ;
36948 PyObject *swig_obj[1] ;
36949
36950 if (!args) SWIG_fail;
36951 swig_obj[0] = args;
36952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36953 if (!SWIG_IsOK(res1)) {
36954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36955 }
36956 arg1 = reinterpret_cast< wxWindow * >(argp1);
36957 {
36958 PyThreadState* __tstate = wxPyBeginAllowThreads();
36959 result = (bool)(arg1)->LineUp();
36960 wxPyEndAllowThreads(__tstate);
36961 if (PyErr_Occurred()) SWIG_fail;
36962 }
36963 {
36964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36965 }
36966 return resultobj;
36967 fail:
36968 return NULL;
36969 }
36970
36971
36972 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36973 PyObject *resultobj = 0;
36974 wxWindow *arg1 = (wxWindow *) 0 ;
36975 bool result;
36976 void *argp1 = 0 ;
36977 int res1 = 0 ;
36978 PyObject *swig_obj[1] ;
36979
36980 if (!args) SWIG_fail;
36981 swig_obj[0] = args;
36982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36983 if (!SWIG_IsOK(res1)) {
36984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36985 }
36986 arg1 = reinterpret_cast< wxWindow * >(argp1);
36987 {
36988 PyThreadState* __tstate = wxPyBeginAllowThreads();
36989 result = (bool)(arg1)->LineDown();
36990 wxPyEndAllowThreads(__tstate);
36991 if (PyErr_Occurred()) SWIG_fail;
36992 }
36993 {
36994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36995 }
36996 return resultobj;
36997 fail:
36998 return NULL;
36999 }
37000
37001
37002 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37003 PyObject *resultobj = 0;
37004 wxWindow *arg1 = (wxWindow *) 0 ;
37005 bool result;
37006 void *argp1 = 0 ;
37007 int res1 = 0 ;
37008 PyObject *swig_obj[1] ;
37009
37010 if (!args) SWIG_fail;
37011 swig_obj[0] = args;
37012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37013 if (!SWIG_IsOK(res1)) {
37014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37015 }
37016 arg1 = reinterpret_cast< wxWindow * >(argp1);
37017 {
37018 PyThreadState* __tstate = wxPyBeginAllowThreads();
37019 result = (bool)(arg1)->PageUp();
37020 wxPyEndAllowThreads(__tstate);
37021 if (PyErr_Occurred()) SWIG_fail;
37022 }
37023 {
37024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37025 }
37026 return resultobj;
37027 fail:
37028 return NULL;
37029 }
37030
37031
37032 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37033 PyObject *resultobj = 0;
37034 wxWindow *arg1 = (wxWindow *) 0 ;
37035 bool result;
37036 void *argp1 = 0 ;
37037 int res1 = 0 ;
37038 PyObject *swig_obj[1] ;
37039
37040 if (!args) SWIG_fail;
37041 swig_obj[0] = args;
37042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37043 if (!SWIG_IsOK(res1)) {
37044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37045 }
37046 arg1 = reinterpret_cast< wxWindow * >(argp1);
37047 {
37048 PyThreadState* __tstate = wxPyBeginAllowThreads();
37049 result = (bool)(arg1)->PageDown();
37050 wxPyEndAllowThreads(__tstate);
37051 if (PyErr_Occurred()) SWIG_fail;
37052 }
37053 {
37054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37055 }
37056 return resultobj;
37057 fail:
37058 return NULL;
37059 }
37060
37061
37062 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37063 PyObject *resultobj = 0;
37064 wxWindow *arg1 = (wxWindow *) 0 ;
37065 wxString *arg2 = 0 ;
37066 void *argp1 = 0 ;
37067 int res1 = 0 ;
37068 bool temp2 = false ;
37069 PyObject * obj0 = 0 ;
37070 PyObject * obj1 = 0 ;
37071 char * kwnames[] = {
37072 (char *) "self",(char *) "text", NULL
37073 };
37074
37075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37077 if (!SWIG_IsOK(res1)) {
37078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37079 }
37080 arg1 = reinterpret_cast< wxWindow * >(argp1);
37081 {
37082 arg2 = wxString_in_helper(obj1);
37083 if (arg2 == NULL) SWIG_fail;
37084 temp2 = true;
37085 }
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 (arg1)->SetHelpText((wxString const &)*arg2);
37089 wxPyEndAllowThreads(__tstate);
37090 if (PyErr_Occurred()) SWIG_fail;
37091 }
37092 resultobj = SWIG_Py_Void();
37093 {
37094 if (temp2)
37095 delete arg2;
37096 }
37097 return resultobj;
37098 fail:
37099 {
37100 if (temp2)
37101 delete arg2;
37102 }
37103 return NULL;
37104 }
37105
37106
37107 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37108 PyObject *resultobj = 0;
37109 wxWindow *arg1 = (wxWindow *) 0 ;
37110 wxString *arg2 = 0 ;
37111 void *argp1 = 0 ;
37112 int res1 = 0 ;
37113 bool temp2 = false ;
37114 PyObject * obj0 = 0 ;
37115 PyObject * obj1 = 0 ;
37116 char * kwnames[] = {
37117 (char *) "self",(char *) "text", NULL
37118 };
37119
37120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37122 if (!SWIG_IsOK(res1)) {
37123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37124 }
37125 arg1 = reinterpret_cast< wxWindow * >(argp1);
37126 {
37127 arg2 = wxString_in_helper(obj1);
37128 if (arg2 == NULL) SWIG_fail;
37129 temp2 = true;
37130 }
37131 {
37132 PyThreadState* __tstate = wxPyBeginAllowThreads();
37133 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 resultobj = SWIG_Py_Void();
37138 {
37139 if (temp2)
37140 delete arg2;
37141 }
37142 return resultobj;
37143 fail:
37144 {
37145 if (temp2)
37146 delete arg2;
37147 }
37148 return NULL;
37149 }
37150
37151
37152 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37153 PyObject *resultobj = 0;
37154 wxWindow *arg1 = (wxWindow *) 0 ;
37155 wxPoint *arg2 = 0 ;
37156 wxHelpEvent::Origin arg3 ;
37157 wxString result;
37158 void *argp1 = 0 ;
37159 int res1 = 0 ;
37160 wxPoint temp2 ;
37161 void *argp3 ;
37162 int res3 = 0 ;
37163 PyObject * obj0 = 0 ;
37164 PyObject * obj1 = 0 ;
37165 PyObject * obj2 = 0 ;
37166 char * kwnames[] = {
37167 (char *) "self",(char *) "pt",(char *) "origin", NULL
37168 };
37169
37170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37172 if (!SWIG_IsOK(res1)) {
37173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37174 }
37175 arg1 = reinterpret_cast< wxWindow * >(argp1);
37176 {
37177 arg2 = &temp2;
37178 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37179 }
37180 {
37181 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37182 if (!SWIG_IsOK(res3)) {
37183 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37184 }
37185 if (!argp3) {
37186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37187 } else {
37188 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37189 arg3 = *temp;
37190 if (SWIG_IsNewObj(res3)) delete temp;
37191 }
37192 }
37193 {
37194 PyThreadState* __tstate = wxPyBeginAllowThreads();
37195 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37196 wxPyEndAllowThreads(__tstate);
37197 if (PyErr_Occurred()) SWIG_fail;
37198 }
37199 {
37200 #if wxUSE_UNICODE
37201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37202 #else
37203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37204 #endif
37205 }
37206 return resultobj;
37207 fail:
37208 return NULL;
37209 }
37210
37211
37212 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37213 PyObject *resultobj = 0;
37214 wxWindow *arg1 = (wxWindow *) 0 ;
37215 wxString result;
37216 void *argp1 = 0 ;
37217 int res1 = 0 ;
37218 PyObject *swig_obj[1] ;
37219
37220 if (!args) SWIG_fail;
37221 swig_obj[0] = args;
37222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37223 if (!SWIG_IsOK(res1)) {
37224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37225 }
37226 arg1 = reinterpret_cast< wxWindow * >(argp1);
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 result = ((wxWindow const *)arg1)->GetHelpText();
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 {
37234 #if wxUSE_UNICODE
37235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37236 #else
37237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37238 #endif
37239 }
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 wxString *arg2 = 0 ;
37250 void *argp1 = 0 ;
37251 int res1 = 0 ;
37252 bool temp2 = false ;
37253 PyObject * obj0 = 0 ;
37254 PyObject * obj1 = 0 ;
37255 char * kwnames[] = {
37256 (char *) "self",(char *) "tip", NULL
37257 };
37258
37259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37261 if (!SWIG_IsOK(res1)) {
37262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37263 }
37264 arg1 = reinterpret_cast< wxWindow * >(argp1);
37265 {
37266 arg2 = wxString_in_helper(obj1);
37267 if (arg2 == NULL) SWIG_fail;
37268 temp2 = true;
37269 }
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 (arg1)->SetToolTip((wxString const &)*arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_Py_Void();
37277 {
37278 if (temp2)
37279 delete arg2;
37280 }
37281 return resultobj;
37282 fail:
37283 {
37284 if (temp2)
37285 delete arg2;
37286 }
37287 return NULL;
37288 }
37289
37290
37291 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37292 PyObject *resultobj = 0;
37293 wxWindow *arg1 = (wxWindow *) 0 ;
37294 wxToolTip *arg2 = (wxToolTip *) 0 ;
37295 void *argp1 = 0 ;
37296 int res1 = 0 ;
37297 int res2 = 0 ;
37298 PyObject * obj0 = 0 ;
37299 PyObject * obj1 = 0 ;
37300 char * kwnames[] = {
37301 (char *) "self",(char *) "tip", NULL
37302 };
37303
37304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37306 if (!SWIG_IsOK(res1)) {
37307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37308 }
37309 arg1 = reinterpret_cast< wxWindow * >(argp1);
37310 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37311 if (!SWIG_IsOK(res2)) {
37312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37313 }
37314 {
37315 PyThreadState* __tstate = wxPyBeginAllowThreads();
37316 (arg1)->SetToolTip(arg2);
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 resultobj = SWIG_Py_Void();
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37328 PyObject *resultobj = 0;
37329 wxWindow *arg1 = (wxWindow *) 0 ;
37330 wxToolTip *result = 0 ;
37331 void *argp1 = 0 ;
37332 int res1 = 0 ;
37333 PyObject *swig_obj[1] ;
37334
37335 if (!args) SWIG_fail;
37336 swig_obj[0] = args;
37337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37338 if (!SWIG_IsOK(res1)) {
37339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37340 }
37341 arg1 = reinterpret_cast< wxWindow * >(argp1);
37342 {
37343 PyThreadState* __tstate = wxPyBeginAllowThreads();
37344 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37345 wxPyEndAllowThreads(__tstate);
37346 if (PyErr_Occurred()) SWIG_fail;
37347 }
37348 {
37349 resultobj = wxPyMake_wxObject(result, (bool)0);
37350 }
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37358 PyObject *resultobj = 0;
37359 wxWindow *arg1 = (wxWindow *) 0 ;
37360 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37361 void *argp1 = 0 ;
37362 int res1 = 0 ;
37363 int res2 = 0 ;
37364 PyObject * obj0 = 0 ;
37365 PyObject * obj1 = 0 ;
37366 char * kwnames[] = {
37367 (char *) "self",(char *) "dropTarget", NULL
37368 };
37369
37370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37372 if (!SWIG_IsOK(res1)) {
37373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37374 }
37375 arg1 = reinterpret_cast< wxWindow * >(argp1);
37376 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37377 if (!SWIG_IsOK(res2)) {
37378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37379 }
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 (arg1)->SetDropTarget(arg2);
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 resultobj = SWIG_Py_Void();
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37394 PyObject *resultobj = 0;
37395 wxWindow *arg1 = (wxWindow *) 0 ;
37396 wxPyDropTarget *result = 0 ;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 PyObject *swig_obj[1] ;
37400
37401 if (!args) SWIG_fail;
37402 swig_obj[0] = args;
37403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37404 if (!SWIG_IsOK(res1)) {
37405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37406 }
37407 arg1 = reinterpret_cast< wxWindow * >(argp1);
37408 {
37409 PyThreadState* __tstate = wxPyBeginAllowThreads();
37410 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37411 wxPyEndAllowThreads(__tstate);
37412 if (PyErr_Occurred()) SWIG_fail;
37413 }
37414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37415 return resultobj;
37416 fail:
37417 return NULL;
37418 }
37419
37420
37421 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37422 PyObject *resultobj = 0;
37423 wxWindow *arg1 = (wxWindow *) 0 ;
37424 bool arg2 ;
37425 void *argp1 = 0 ;
37426 int res1 = 0 ;
37427 bool val2 ;
37428 int ecode2 = 0 ;
37429 PyObject * obj0 = 0 ;
37430 PyObject * obj1 = 0 ;
37431 char * kwnames[] = {
37432 (char *) "self",(char *) "accept", NULL
37433 };
37434
37435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37437 if (!SWIG_IsOK(res1)) {
37438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37439 }
37440 arg1 = reinterpret_cast< wxWindow * >(argp1);
37441 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37442 if (!SWIG_IsOK(ecode2)) {
37443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37444 }
37445 arg2 = static_cast< bool >(val2);
37446 {
37447 PyThreadState* __tstate = wxPyBeginAllowThreads();
37448 (arg1)->DragAcceptFiles(arg2);
37449 wxPyEndAllowThreads(__tstate);
37450 if (PyErr_Occurred()) SWIG_fail;
37451 }
37452 resultobj = SWIG_Py_Void();
37453 return resultobj;
37454 fail:
37455 return NULL;
37456 }
37457
37458
37459 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37460 PyObject *resultobj = 0;
37461 wxWindow *arg1 = (wxWindow *) 0 ;
37462 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37463 void *argp1 = 0 ;
37464 int res1 = 0 ;
37465 int res2 = 0 ;
37466 PyObject * obj0 = 0 ;
37467 PyObject * obj1 = 0 ;
37468 char * kwnames[] = {
37469 (char *) "self",(char *) "constraints", NULL
37470 };
37471
37472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37474 if (!SWIG_IsOK(res1)) {
37475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37476 }
37477 arg1 = reinterpret_cast< wxWindow * >(argp1);
37478 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37479 if (!SWIG_IsOK(res2)) {
37480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37481 }
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 (arg1)->SetConstraints(arg2);
37485 wxPyEndAllowThreads(__tstate);
37486 if (PyErr_Occurred()) SWIG_fail;
37487 }
37488 resultobj = SWIG_Py_Void();
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37496 PyObject *resultobj = 0;
37497 wxWindow *arg1 = (wxWindow *) 0 ;
37498 wxLayoutConstraints *result = 0 ;
37499 void *argp1 = 0 ;
37500 int res1 = 0 ;
37501 PyObject *swig_obj[1] ;
37502
37503 if (!args) SWIG_fail;
37504 swig_obj[0] = args;
37505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37506 if (!SWIG_IsOK(res1)) {
37507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37508 }
37509 arg1 = reinterpret_cast< wxWindow * >(argp1);
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37517 return resultobj;
37518 fail:
37519 return NULL;
37520 }
37521
37522
37523 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37524 PyObject *resultobj = 0;
37525 wxWindow *arg1 = (wxWindow *) 0 ;
37526 bool arg2 ;
37527 void *argp1 = 0 ;
37528 int res1 = 0 ;
37529 bool val2 ;
37530 int ecode2 = 0 ;
37531 PyObject * obj0 = 0 ;
37532 PyObject * obj1 = 0 ;
37533 char * kwnames[] = {
37534 (char *) "self",(char *) "autoLayout", NULL
37535 };
37536
37537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37539 if (!SWIG_IsOK(res1)) {
37540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37541 }
37542 arg1 = reinterpret_cast< wxWindow * >(argp1);
37543 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37544 if (!SWIG_IsOK(ecode2)) {
37545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37546 }
37547 arg2 = static_cast< bool >(val2);
37548 {
37549 PyThreadState* __tstate = wxPyBeginAllowThreads();
37550 (arg1)->SetAutoLayout(arg2);
37551 wxPyEndAllowThreads(__tstate);
37552 if (PyErr_Occurred()) SWIG_fail;
37553 }
37554 resultobj = SWIG_Py_Void();
37555 return resultobj;
37556 fail:
37557 return NULL;
37558 }
37559
37560
37561 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37562 PyObject *resultobj = 0;
37563 wxWindow *arg1 = (wxWindow *) 0 ;
37564 bool result;
37565 void *argp1 = 0 ;
37566 int res1 = 0 ;
37567 PyObject *swig_obj[1] ;
37568
37569 if (!args) SWIG_fail;
37570 swig_obj[0] = args;
37571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37574 }
37575 arg1 = reinterpret_cast< wxWindow * >(argp1);
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 {
37583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37584 }
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37592 PyObject *resultobj = 0;
37593 wxWindow *arg1 = (wxWindow *) 0 ;
37594 bool result;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 PyObject *swig_obj[1] ;
37598
37599 if (!args) SWIG_fail;
37600 swig_obj[0] = args;
37601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37602 if (!SWIG_IsOK(res1)) {
37603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37604 }
37605 arg1 = reinterpret_cast< wxWindow * >(argp1);
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 result = (bool)(arg1)->Layout();
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 {
37613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37614 }
37615 return resultobj;
37616 fail:
37617 return NULL;
37618 }
37619
37620
37621 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37622 PyObject *resultobj = 0;
37623 wxWindow *arg1 = (wxWindow *) 0 ;
37624 wxSizer *arg2 = (wxSizer *) 0 ;
37625 bool arg3 = (bool) true ;
37626 void *argp1 = 0 ;
37627 int res1 = 0 ;
37628 int res2 = 0 ;
37629 bool val3 ;
37630 int ecode3 = 0 ;
37631 PyObject * obj0 = 0 ;
37632 PyObject * obj1 = 0 ;
37633 PyObject * obj2 = 0 ;
37634 char * kwnames[] = {
37635 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37636 };
37637
37638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37640 if (!SWIG_IsOK(res1)) {
37641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37642 }
37643 arg1 = reinterpret_cast< wxWindow * >(argp1);
37644 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37645 if (!SWIG_IsOK(res2)) {
37646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37647 }
37648 if (obj2) {
37649 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37650 if (!SWIG_IsOK(ecode3)) {
37651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37652 }
37653 arg3 = static_cast< bool >(val3);
37654 }
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 (arg1)->SetSizer(arg2,arg3);
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 resultobj = SWIG_Py_Void();
37662 return resultobj;
37663 fail:
37664 return NULL;
37665 }
37666
37667
37668 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37669 PyObject *resultobj = 0;
37670 wxWindow *arg1 = (wxWindow *) 0 ;
37671 wxSizer *arg2 = (wxSizer *) 0 ;
37672 bool arg3 = (bool) true ;
37673 void *argp1 = 0 ;
37674 int res1 = 0 ;
37675 int res2 = 0 ;
37676 bool val3 ;
37677 int ecode3 = 0 ;
37678 PyObject * obj0 = 0 ;
37679 PyObject * obj1 = 0 ;
37680 PyObject * obj2 = 0 ;
37681 char * kwnames[] = {
37682 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37683 };
37684
37685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37687 if (!SWIG_IsOK(res1)) {
37688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37689 }
37690 arg1 = reinterpret_cast< wxWindow * >(argp1);
37691 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37692 if (!SWIG_IsOK(res2)) {
37693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37694 }
37695 if (obj2) {
37696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37697 if (!SWIG_IsOK(ecode3)) {
37698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37699 }
37700 arg3 = static_cast< bool >(val3);
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 (arg1)->SetSizerAndFit(arg2,arg3);
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 resultobj = SWIG_Py_Void();
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37716 PyObject *resultobj = 0;
37717 wxWindow *arg1 = (wxWindow *) 0 ;
37718 wxSizer *result = 0 ;
37719 void *argp1 = 0 ;
37720 int res1 = 0 ;
37721 PyObject *swig_obj[1] ;
37722
37723 if (!args) SWIG_fail;
37724 swig_obj[0] = args;
37725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37726 if (!SWIG_IsOK(res1)) {
37727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37728 }
37729 arg1 = reinterpret_cast< wxWindow * >(argp1);
37730 {
37731 PyThreadState* __tstate = wxPyBeginAllowThreads();
37732 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37733 wxPyEndAllowThreads(__tstate);
37734 if (PyErr_Occurred()) SWIG_fail;
37735 }
37736 {
37737 resultobj = wxPyMake_wxObject(result, (bool)0);
37738 }
37739 return resultobj;
37740 fail:
37741 return NULL;
37742 }
37743
37744
37745 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37746 PyObject *resultobj = 0;
37747 wxWindow *arg1 = (wxWindow *) 0 ;
37748 wxSizer *arg2 = (wxSizer *) 0 ;
37749 void *argp1 = 0 ;
37750 int res1 = 0 ;
37751 void *argp2 = 0 ;
37752 int res2 = 0 ;
37753 PyObject * obj0 = 0 ;
37754 PyObject * obj1 = 0 ;
37755 char * kwnames[] = {
37756 (char *) "self",(char *) "sizer", NULL
37757 };
37758
37759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37761 if (!SWIG_IsOK(res1)) {
37762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37763 }
37764 arg1 = reinterpret_cast< wxWindow * >(argp1);
37765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37766 if (!SWIG_IsOK(res2)) {
37767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37768 }
37769 arg2 = reinterpret_cast< wxSizer * >(argp2);
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 (arg1)->SetContainingSizer(arg2);
37773 wxPyEndAllowThreads(__tstate);
37774 if (PyErr_Occurred()) SWIG_fail;
37775 }
37776 resultobj = SWIG_Py_Void();
37777 return resultobj;
37778 fail:
37779 return NULL;
37780 }
37781
37782
37783 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37784 PyObject *resultobj = 0;
37785 wxWindow *arg1 = (wxWindow *) 0 ;
37786 wxSizer *result = 0 ;
37787 void *argp1 = 0 ;
37788 int res1 = 0 ;
37789 PyObject *swig_obj[1] ;
37790
37791 if (!args) SWIG_fail;
37792 swig_obj[0] = args;
37793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37794 if (!SWIG_IsOK(res1)) {
37795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37796 }
37797 arg1 = reinterpret_cast< wxWindow * >(argp1);
37798 {
37799 PyThreadState* __tstate = wxPyBeginAllowThreads();
37800 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37801 wxPyEndAllowThreads(__tstate);
37802 if (PyErr_Occurred()) SWIG_fail;
37803 }
37804 {
37805 resultobj = wxPyMake_wxObject(result, (bool)0);
37806 }
37807 return resultobj;
37808 fail:
37809 return NULL;
37810 }
37811
37812
37813 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37814 PyObject *resultobj = 0;
37815 wxWindow *arg1 = (wxWindow *) 0 ;
37816 void *argp1 = 0 ;
37817 int res1 = 0 ;
37818 PyObject *swig_obj[1] ;
37819
37820 if (!args) SWIG_fail;
37821 swig_obj[0] = args;
37822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37823 if (!SWIG_IsOK(res1)) {
37824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37825 }
37826 arg1 = reinterpret_cast< wxWindow * >(argp1);
37827 {
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 (arg1)->InheritAttributes();
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 resultobj = SWIG_Py_Void();
37834 return resultobj;
37835 fail:
37836 return NULL;
37837 }
37838
37839
37840 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37841 PyObject *resultobj = 0;
37842 wxWindow *arg1 = (wxWindow *) 0 ;
37843 bool result;
37844 void *argp1 = 0 ;
37845 int res1 = 0 ;
37846 PyObject *swig_obj[1] ;
37847
37848 if (!args) SWIG_fail;
37849 swig_obj[0] = args;
37850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37851 if (!SWIG_IsOK(res1)) {
37852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37853 }
37854 arg1 = reinterpret_cast< wxWindow * >(argp1);
37855 {
37856 PyThreadState* __tstate = wxPyBeginAllowThreads();
37857 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37858 wxPyEndAllowThreads(__tstate);
37859 if (PyErr_Occurred()) SWIG_fail;
37860 }
37861 {
37862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37863 }
37864 return resultobj;
37865 fail:
37866 return NULL;
37867 }
37868
37869
37870 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37871 PyObject *resultobj = 0;
37872 wxWindow *arg1 = (wxWindow *) 0 ;
37873 bool result;
37874 void *argp1 = 0 ;
37875 int res1 = 0 ;
37876 PyObject *swig_obj[1] ;
37877
37878 if (!args) SWIG_fail;
37879 swig_obj[0] = args;
37880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37881 if (!SWIG_IsOK(res1)) {
37882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37883 }
37884 arg1 = reinterpret_cast< wxWindow * >(argp1);
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 result = (bool)(arg1)->CanSetTransparent();
37888 wxPyEndAllowThreads(__tstate);
37889 if (PyErr_Occurred()) SWIG_fail;
37890 }
37891 {
37892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37893 }
37894 return resultobj;
37895 fail:
37896 return NULL;
37897 }
37898
37899
37900 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37901 PyObject *resultobj = 0;
37902 wxWindow *arg1 = (wxWindow *) 0 ;
37903 byte arg2 ;
37904 bool result;
37905 void *argp1 = 0 ;
37906 int res1 = 0 ;
37907 unsigned char val2 ;
37908 int ecode2 = 0 ;
37909 PyObject * obj0 = 0 ;
37910 PyObject * obj1 = 0 ;
37911 char * kwnames[] = {
37912 (char *) "self",(char *) "alpha", NULL
37913 };
37914
37915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37919 }
37920 arg1 = reinterpret_cast< wxWindow * >(argp1);
37921 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37922 if (!SWIG_IsOK(ecode2)) {
37923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37924 }
37925 arg2 = static_cast< byte >(val2);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (bool)(arg1)->SetTransparent(arg2);
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 {
37933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37934 }
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37942 PyObject *obj;
37943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37944 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37945 return SWIG_Py_Void();
37946 }
37947
37948 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37949 return SWIG_Python_InitShadowInstance(args);
37950 }
37951
37952 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37953 PyObject *resultobj = 0;
37954 long arg1 ;
37955 wxWindow *arg2 = (wxWindow *) NULL ;
37956 wxWindow *result = 0 ;
37957 long val1 ;
37958 int ecode1 = 0 ;
37959 void *argp2 = 0 ;
37960 int res2 = 0 ;
37961 PyObject * obj0 = 0 ;
37962 PyObject * obj1 = 0 ;
37963 char * kwnames[] = {
37964 (char *) "id",(char *) "parent", NULL
37965 };
37966
37967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37968 ecode1 = SWIG_AsVal_long(obj0, &val1);
37969 if (!SWIG_IsOK(ecode1)) {
37970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37971 }
37972 arg1 = static_cast< long >(val1);
37973 if (obj1) {
37974 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37975 if (!SWIG_IsOK(res2)) {
37976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37977 }
37978 arg2 = reinterpret_cast< wxWindow * >(argp2);
37979 }
37980 {
37981 if (!wxPyCheckForApp()) SWIG_fail;
37982 PyThreadState* __tstate = wxPyBeginAllowThreads();
37983 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37984 wxPyEndAllowThreads(__tstate);
37985 if (PyErr_Occurred()) SWIG_fail;
37986 }
37987 {
37988 resultobj = wxPyMake_wxObject(result, 0);
37989 }
37990 return resultobj;
37991 fail:
37992 return NULL;
37993 }
37994
37995
37996 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37997 PyObject *resultobj = 0;
37998 wxString *arg1 = 0 ;
37999 wxWindow *arg2 = (wxWindow *) NULL ;
38000 wxWindow *result = 0 ;
38001 bool temp1 = false ;
38002 void *argp2 = 0 ;
38003 int res2 = 0 ;
38004 PyObject * obj0 = 0 ;
38005 PyObject * obj1 = 0 ;
38006 char * kwnames[] = {
38007 (char *) "name",(char *) "parent", NULL
38008 };
38009
38010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38011 {
38012 arg1 = wxString_in_helper(obj0);
38013 if (arg1 == NULL) SWIG_fail;
38014 temp1 = true;
38015 }
38016 if (obj1) {
38017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38018 if (!SWIG_IsOK(res2)) {
38019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38020 }
38021 arg2 = reinterpret_cast< wxWindow * >(argp2);
38022 }
38023 {
38024 if (!wxPyCheckForApp()) SWIG_fail;
38025 PyThreadState* __tstate = wxPyBeginAllowThreads();
38026 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 {
38031 resultobj = wxPyMake_wxObject(result, 0);
38032 }
38033 {
38034 if (temp1)
38035 delete arg1;
38036 }
38037 return resultobj;
38038 fail:
38039 {
38040 if (temp1)
38041 delete arg1;
38042 }
38043 return NULL;
38044 }
38045
38046
38047 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38048 PyObject *resultobj = 0;
38049 wxString *arg1 = 0 ;
38050 wxWindow *arg2 = (wxWindow *) NULL ;
38051 wxWindow *result = 0 ;
38052 bool temp1 = false ;
38053 void *argp2 = 0 ;
38054 int res2 = 0 ;
38055 PyObject * obj0 = 0 ;
38056 PyObject * obj1 = 0 ;
38057 char * kwnames[] = {
38058 (char *) "label",(char *) "parent", NULL
38059 };
38060
38061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38062 {
38063 arg1 = wxString_in_helper(obj0);
38064 if (arg1 == NULL) SWIG_fail;
38065 temp1 = true;
38066 }
38067 if (obj1) {
38068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38069 if (!SWIG_IsOK(res2)) {
38070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38071 }
38072 arg2 = reinterpret_cast< wxWindow * >(argp2);
38073 }
38074 {
38075 if (!wxPyCheckForApp()) SWIG_fail;
38076 PyThreadState* __tstate = wxPyBeginAllowThreads();
38077 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38078 wxPyEndAllowThreads(__tstate);
38079 if (PyErr_Occurred()) SWIG_fail;
38080 }
38081 {
38082 resultobj = wxPyMake_wxObject(result, 0);
38083 }
38084 {
38085 if (temp1)
38086 delete arg1;
38087 }
38088 return resultobj;
38089 fail:
38090 {
38091 if (temp1)
38092 delete arg1;
38093 }
38094 return NULL;
38095 }
38096
38097
38098 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38099 PyObject *resultobj = 0;
38100 wxWindow *arg1 = (wxWindow *) 0 ;
38101 unsigned long arg2 ;
38102 wxWindow *result = 0 ;
38103 void *argp1 = 0 ;
38104 int res1 = 0 ;
38105 unsigned long val2 ;
38106 int ecode2 = 0 ;
38107 PyObject * obj0 = 0 ;
38108 PyObject * obj1 = 0 ;
38109 char * kwnames[] = {
38110 (char *) "parent",(char *) "_hWnd", NULL
38111 };
38112
38113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38115 if (!SWIG_IsOK(res1)) {
38116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38117 }
38118 arg1 = reinterpret_cast< wxWindow * >(argp1);
38119 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38120 if (!SWIG_IsOK(ecode2)) {
38121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38122 }
38123 arg2 = static_cast< unsigned long >(val2);
38124 {
38125 PyThreadState* __tstate = wxPyBeginAllowThreads();
38126 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38127 wxPyEndAllowThreads(__tstate);
38128 if (PyErr_Occurred()) SWIG_fail;
38129 }
38130 {
38131 resultobj = wxPyMake_wxObject(result, 0);
38132 }
38133 return resultobj;
38134 fail:
38135 return NULL;
38136 }
38137
38138
38139 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38140 PyObject *resultobj = 0;
38141 PyObject *result = 0 ;
38142
38143 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 result = (PyObject *)GetTopLevelWindows();
38147 wxPyEndAllowThreads(__tstate);
38148 if (PyErr_Occurred()) SWIG_fail;
38149 }
38150 resultobj = result;
38151 return resultobj;
38152 fail:
38153 return NULL;
38154 }
38155
38156
38157 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38158 PyObject *resultobj = 0;
38159 wxValidator *result = 0 ;
38160
38161 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38162 {
38163 PyThreadState* __tstate = wxPyBeginAllowThreads();
38164 result = (wxValidator *)new wxValidator();
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38169 return resultobj;
38170 fail:
38171 return NULL;
38172 }
38173
38174
38175 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38176 PyObject *resultobj = 0;
38177 wxValidator *arg1 = (wxValidator *) 0 ;
38178 wxValidator *result = 0 ;
38179 void *argp1 = 0 ;
38180 int res1 = 0 ;
38181 PyObject *swig_obj[1] ;
38182
38183 if (!args) SWIG_fail;
38184 swig_obj[0] = args;
38185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38186 if (!SWIG_IsOK(res1)) {
38187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38188 }
38189 arg1 = reinterpret_cast< wxValidator * >(argp1);
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 result = (wxValidator *)(arg1)->Clone();
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 {
38197 resultobj = wxPyMake_wxObject(result, 0);
38198 }
38199 return resultobj;
38200 fail:
38201 return NULL;
38202 }
38203
38204
38205 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38206 PyObject *resultobj = 0;
38207 wxValidator *arg1 = (wxValidator *) 0 ;
38208 wxWindow *arg2 = (wxWindow *) 0 ;
38209 bool result;
38210 void *argp1 = 0 ;
38211 int res1 = 0 ;
38212 void *argp2 = 0 ;
38213 int res2 = 0 ;
38214 PyObject * obj0 = 0 ;
38215 PyObject * obj1 = 0 ;
38216 char * kwnames[] = {
38217 (char *) "self",(char *) "parent", NULL
38218 };
38219
38220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38222 if (!SWIG_IsOK(res1)) {
38223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38224 }
38225 arg1 = reinterpret_cast< wxValidator * >(argp1);
38226 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38227 if (!SWIG_IsOK(res2)) {
38228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38229 }
38230 arg2 = reinterpret_cast< wxWindow * >(argp2);
38231 {
38232 PyThreadState* __tstate = wxPyBeginAllowThreads();
38233 result = (bool)(arg1)->Validate(arg2);
38234 wxPyEndAllowThreads(__tstate);
38235 if (PyErr_Occurred()) SWIG_fail;
38236 }
38237 {
38238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38239 }
38240 return resultobj;
38241 fail:
38242 return NULL;
38243 }
38244
38245
38246 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38247 PyObject *resultobj = 0;
38248 wxValidator *arg1 = (wxValidator *) 0 ;
38249 bool result;
38250 void *argp1 = 0 ;
38251 int res1 = 0 ;
38252 PyObject *swig_obj[1] ;
38253
38254 if (!args) SWIG_fail;
38255 swig_obj[0] = args;
38256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38257 if (!SWIG_IsOK(res1)) {
38258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38259 }
38260 arg1 = reinterpret_cast< wxValidator * >(argp1);
38261 {
38262 PyThreadState* __tstate = wxPyBeginAllowThreads();
38263 result = (bool)(arg1)->TransferToWindow();
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 {
38268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38269 }
38270 return resultobj;
38271 fail:
38272 return NULL;
38273 }
38274
38275
38276 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38277 PyObject *resultobj = 0;
38278 wxValidator *arg1 = (wxValidator *) 0 ;
38279 bool result;
38280 void *argp1 = 0 ;
38281 int res1 = 0 ;
38282 PyObject *swig_obj[1] ;
38283
38284 if (!args) SWIG_fail;
38285 swig_obj[0] = args;
38286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38287 if (!SWIG_IsOK(res1)) {
38288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38289 }
38290 arg1 = reinterpret_cast< wxValidator * >(argp1);
38291 {
38292 PyThreadState* __tstate = wxPyBeginAllowThreads();
38293 result = (bool)(arg1)->TransferFromWindow();
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 {
38298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38299 }
38300 return resultobj;
38301 fail:
38302 return NULL;
38303 }
38304
38305
38306 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38307 PyObject *resultobj = 0;
38308 wxValidator *arg1 = (wxValidator *) 0 ;
38309 wxWindow *result = 0 ;
38310 void *argp1 = 0 ;
38311 int res1 = 0 ;
38312 PyObject *swig_obj[1] ;
38313
38314 if (!args) SWIG_fail;
38315 swig_obj[0] = args;
38316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38317 if (!SWIG_IsOK(res1)) {
38318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38319 }
38320 arg1 = reinterpret_cast< wxValidator * >(argp1);
38321 {
38322 PyThreadState* __tstate = wxPyBeginAllowThreads();
38323 result = (wxWindow *)(arg1)->GetWindow();
38324 wxPyEndAllowThreads(__tstate);
38325 if (PyErr_Occurred()) SWIG_fail;
38326 }
38327 {
38328 resultobj = wxPyMake_wxObject(result, 0);
38329 }
38330 return resultobj;
38331 fail:
38332 return NULL;
38333 }
38334
38335
38336 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38337 PyObject *resultobj = 0;
38338 wxValidator *arg1 = (wxValidator *) 0 ;
38339 wxWindow *arg2 = (wxWindow *) 0 ;
38340 void *argp1 = 0 ;
38341 int res1 = 0 ;
38342 void *argp2 = 0 ;
38343 int res2 = 0 ;
38344 PyObject * obj0 = 0 ;
38345 PyObject * obj1 = 0 ;
38346 char * kwnames[] = {
38347 (char *) "self",(char *) "window", NULL
38348 };
38349
38350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38352 if (!SWIG_IsOK(res1)) {
38353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38354 }
38355 arg1 = reinterpret_cast< wxValidator * >(argp1);
38356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38357 if (!SWIG_IsOK(res2)) {
38358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38359 }
38360 arg2 = reinterpret_cast< wxWindow * >(argp2);
38361 {
38362 PyThreadState* __tstate = wxPyBeginAllowThreads();
38363 (arg1)->SetWindow(arg2);
38364 wxPyEndAllowThreads(__tstate);
38365 if (PyErr_Occurred()) SWIG_fail;
38366 }
38367 resultobj = SWIG_Py_Void();
38368 return resultobj;
38369 fail:
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38375 PyObject *resultobj = 0;
38376 bool result;
38377
38378 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38379 {
38380 PyThreadState* __tstate = wxPyBeginAllowThreads();
38381 result = (bool)wxValidator::IsSilent();
38382 wxPyEndAllowThreads(__tstate);
38383 if (PyErr_Occurred()) SWIG_fail;
38384 }
38385 {
38386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38387 }
38388 return resultobj;
38389 fail:
38390 return NULL;
38391 }
38392
38393
38394 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38395 PyObject *resultobj = 0;
38396 int arg1 = (int) true ;
38397 int val1 ;
38398 int ecode1 = 0 ;
38399 PyObject * obj0 = 0 ;
38400 char * kwnames[] = {
38401 (char *) "doIt", NULL
38402 };
38403
38404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38405 if (obj0) {
38406 ecode1 = SWIG_AsVal_int(obj0, &val1);
38407 if (!SWIG_IsOK(ecode1)) {
38408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38409 }
38410 arg1 = static_cast< int >(val1);
38411 }
38412 {
38413 PyThreadState* __tstate = wxPyBeginAllowThreads();
38414 wxValidator::SetBellOnError(arg1);
38415 wxPyEndAllowThreads(__tstate);
38416 if (PyErr_Occurred()) SWIG_fail;
38417 }
38418 resultobj = SWIG_Py_Void();
38419 return resultobj;
38420 fail:
38421 return NULL;
38422 }
38423
38424
38425 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38426 PyObject *obj;
38427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38428 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38429 return SWIG_Py_Void();
38430 }
38431
38432 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38433 return SWIG_Python_InitShadowInstance(args);
38434 }
38435
38436 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38437 PyObject *resultobj = 0;
38438 wxPyValidator *result = 0 ;
38439
38440 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38441 {
38442 PyThreadState* __tstate = wxPyBeginAllowThreads();
38443 result = (wxPyValidator *)new wxPyValidator();
38444 wxPyEndAllowThreads(__tstate);
38445 if (PyErr_Occurred()) SWIG_fail;
38446 }
38447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38448 return resultobj;
38449 fail:
38450 return NULL;
38451 }
38452
38453
38454 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38455 PyObject *resultobj = 0;
38456 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38457 PyObject *arg2 = (PyObject *) 0 ;
38458 PyObject *arg3 = (PyObject *) 0 ;
38459 int arg4 = (int) true ;
38460 void *argp1 = 0 ;
38461 int res1 = 0 ;
38462 int val4 ;
38463 int ecode4 = 0 ;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 PyObject * obj2 = 0 ;
38467 PyObject * obj3 = 0 ;
38468 char * kwnames[] = {
38469 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38470 };
38471
38472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38474 if (!SWIG_IsOK(res1)) {
38475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38476 }
38477 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38478 arg2 = obj1;
38479 arg3 = obj2;
38480 if (obj3) {
38481 ecode4 = SWIG_AsVal_int(obj3, &val4);
38482 if (!SWIG_IsOK(ecode4)) {
38483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38484 }
38485 arg4 = static_cast< int >(val4);
38486 }
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38490 wxPyEndAllowThreads(__tstate);
38491 if (PyErr_Occurred()) SWIG_fail;
38492 }
38493 resultobj = SWIG_Py_Void();
38494 return resultobj;
38495 fail:
38496 return NULL;
38497 }
38498
38499
38500 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38501 PyObject *obj;
38502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38503 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38504 return SWIG_Py_Void();
38505 }
38506
38507 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38508 return SWIG_Python_InitShadowInstance(args);
38509 }
38510
38511 SWIGINTERN int DefaultValidator_set(PyObject *) {
38512 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38513 return 1;
38514 }
38515
38516
38517 SWIGINTERN PyObject *DefaultValidator_get(void) {
38518 PyObject *pyobj = 0;
38519
38520 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38521 return pyobj;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj = 0;
38527 wxString const &arg1_defvalue = wxPyEmptyString ;
38528 wxString *arg1 = (wxString *) &arg1_defvalue ;
38529 long arg2 = (long) 0 ;
38530 wxMenu *result = 0 ;
38531 bool temp1 = false ;
38532 long val2 ;
38533 int ecode2 = 0 ;
38534 PyObject * obj0 = 0 ;
38535 PyObject * obj1 = 0 ;
38536 char * kwnames[] = {
38537 (char *) "title",(char *) "style", NULL
38538 };
38539
38540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38541 if (obj0) {
38542 {
38543 arg1 = wxString_in_helper(obj0);
38544 if (arg1 == NULL) SWIG_fail;
38545 temp1 = true;
38546 }
38547 }
38548 if (obj1) {
38549 ecode2 = SWIG_AsVal_long(obj1, &val2);
38550 if (!SWIG_IsOK(ecode2)) {
38551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38552 }
38553 arg2 = static_cast< long >(val2);
38554 }
38555 {
38556 if (!wxPyCheckForApp()) SWIG_fail;
38557 PyThreadState* __tstate = wxPyBeginAllowThreads();
38558 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38563 {
38564 if (temp1)
38565 delete arg1;
38566 }
38567 return resultobj;
38568 fail:
38569 {
38570 if (temp1)
38571 delete arg1;
38572 }
38573 return NULL;
38574 }
38575
38576
38577 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38578 PyObject *resultobj = 0;
38579 wxMenu *arg1 = (wxMenu *) 0 ;
38580 int arg2 ;
38581 wxString *arg3 = 0 ;
38582 wxString const &arg4_defvalue = wxPyEmptyString ;
38583 wxString *arg4 = (wxString *) &arg4_defvalue ;
38584 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38585 wxMenuItem *result = 0 ;
38586 void *argp1 = 0 ;
38587 int res1 = 0 ;
38588 int val2 ;
38589 int ecode2 = 0 ;
38590 bool temp3 = false ;
38591 bool temp4 = false ;
38592 int val5 ;
38593 int ecode5 = 0 ;
38594 PyObject * obj0 = 0 ;
38595 PyObject * obj1 = 0 ;
38596 PyObject * obj2 = 0 ;
38597 PyObject * obj3 = 0 ;
38598 PyObject * obj4 = 0 ;
38599 char * kwnames[] = {
38600 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38601 };
38602
38603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38605 if (!SWIG_IsOK(res1)) {
38606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38607 }
38608 arg1 = reinterpret_cast< wxMenu * >(argp1);
38609 ecode2 = SWIG_AsVal_int(obj1, &val2);
38610 if (!SWIG_IsOK(ecode2)) {
38611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38612 }
38613 arg2 = static_cast< int >(val2);
38614 {
38615 arg3 = wxString_in_helper(obj2);
38616 if (arg3 == NULL) SWIG_fail;
38617 temp3 = true;
38618 }
38619 if (obj3) {
38620 {
38621 arg4 = wxString_in_helper(obj3);
38622 if (arg4 == NULL) SWIG_fail;
38623 temp4 = true;
38624 }
38625 }
38626 if (obj4) {
38627 ecode5 = SWIG_AsVal_int(obj4, &val5);
38628 if (!SWIG_IsOK(ecode5)) {
38629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38630 }
38631 arg5 = static_cast< wxItemKind >(val5);
38632 }
38633 {
38634 PyThreadState* __tstate = wxPyBeginAllowThreads();
38635 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38636 wxPyEndAllowThreads(__tstate);
38637 if (PyErr_Occurred()) SWIG_fail;
38638 }
38639 {
38640 resultobj = wxPyMake_wxObject(result, (bool)0);
38641 }
38642 {
38643 if (temp3)
38644 delete arg3;
38645 }
38646 {
38647 if (temp4)
38648 delete arg4;
38649 }
38650 return resultobj;
38651 fail:
38652 {
38653 if (temp3)
38654 delete arg3;
38655 }
38656 {
38657 if (temp4)
38658 delete arg4;
38659 }
38660 return NULL;
38661 }
38662
38663
38664 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38665 PyObject *resultobj = 0;
38666 wxMenu *arg1 = (wxMenu *) 0 ;
38667 wxMenuItem *result = 0 ;
38668 void *argp1 = 0 ;
38669 int res1 = 0 ;
38670 PyObject *swig_obj[1] ;
38671
38672 if (!args) SWIG_fail;
38673 swig_obj[0] = args;
38674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38675 if (!SWIG_IsOK(res1)) {
38676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38677 }
38678 arg1 = reinterpret_cast< wxMenu * >(argp1);
38679 {
38680 PyThreadState* __tstate = wxPyBeginAllowThreads();
38681 result = (wxMenuItem *)(arg1)->AppendSeparator();
38682 wxPyEndAllowThreads(__tstate);
38683 if (PyErr_Occurred()) SWIG_fail;
38684 }
38685 {
38686 resultobj = wxPyMake_wxObject(result, (bool)0);
38687 }
38688 return resultobj;
38689 fail:
38690 return NULL;
38691 }
38692
38693
38694 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38695 PyObject *resultobj = 0;
38696 wxMenu *arg1 = (wxMenu *) 0 ;
38697 int arg2 ;
38698 wxString *arg3 = 0 ;
38699 wxString const &arg4_defvalue = wxPyEmptyString ;
38700 wxString *arg4 = (wxString *) &arg4_defvalue ;
38701 wxMenuItem *result = 0 ;
38702 void *argp1 = 0 ;
38703 int res1 = 0 ;
38704 int val2 ;
38705 int ecode2 = 0 ;
38706 bool temp3 = false ;
38707 bool temp4 = false ;
38708 PyObject * obj0 = 0 ;
38709 PyObject * obj1 = 0 ;
38710 PyObject * obj2 = 0 ;
38711 PyObject * obj3 = 0 ;
38712 char * kwnames[] = {
38713 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38714 };
38715
38716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38718 if (!SWIG_IsOK(res1)) {
38719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38720 }
38721 arg1 = reinterpret_cast< wxMenu * >(argp1);
38722 ecode2 = SWIG_AsVal_int(obj1, &val2);
38723 if (!SWIG_IsOK(ecode2)) {
38724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38725 }
38726 arg2 = static_cast< int >(val2);
38727 {
38728 arg3 = wxString_in_helper(obj2);
38729 if (arg3 == NULL) SWIG_fail;
38730 temp3 = true;
38731 }
38732 if (obj3) {
38733 {
38734 arg4 = wxString_in_helper(obj3);
38735 if (arg4 == NULL) SWIG_fail;
38736 temp4 = true;
38737 }
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 resultobj = wxPyMake_wxObject(result, (bool)0);
38747 }
38748 {
38749 if (temp3)
38750 delete arg3;
38751 }
38752 {
38753 if (temp4)
38754 delete arg4;
38755 }
38756 return resultobj;
38757 fail:
38758 {
38759 if (temp3)
38760 delete arg3;
38761 }
38762 {
38763 if (temp4)
38764 delete arg4;
38765 }
38766 return NULL;
38767 }
38768
38769
38770 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38771 PyObject *resultobj = 0;
38772 wxMenu *arg1 = (wxMenu *) 0 ;
38773 int arg2 ;
38774 wxString *arg3 = 0 ;
38775 wxString const &arg4_defvalue = wxPyEmptyString ;
38776 wxString *arg4 = (wxString *) &arg4_defvalue ;
38777 wxMenuItem *result = 0 ;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 int val2 ;
38781 int ecode2 = 0 ;
38782 bool temp3 = false ;
38783 bool temp4 = false ;
38784 PyObject * obj0 = 0 ;
38785 PyObject * obj1 = 0 ;
38786 PyObject * obj2 = 0 ;
38787 PyObject * obj3 = 0 ;
38788 char * kwnames[] = {
38789 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38790 };
38791
38792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38794 if (!SWIG_IsOK(res1)) {
38795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38796 }
38797 arg1 = reinterpret_cast< wxMenu * >(argp1);
38798 ecode2 = SWIG_AsVal_int(obj1, &val2);
38799 if (!SWIG_IsOK(ecode2)) {
38800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38801 }
38802 arg2 = static_cast< int >(val2);
38803 {
38804 arg3 = wxString_in_helper(obj2);
38805 if (arg3 == NULL) SWIG_fail;
38806 temp3 = true;
38807 }
38808 if (obj3) {
38809 {
38810 arg4 = wxString_in_helper(obj3);
38811 if (arg4 == NULL) SWIG_fail;
38812 temp4 = true;
38813 }
38814 }
38815 {
38816 PyThreadState* __tstate = wxPyBeginAllowThreads();
38817 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38818 wxPyEndAllowThreads(__tstate);
38819 if (PyErr_Occurred()) SWIG_fail;
38820 }
38821 {
38822 resultobj = wxPyMake_wxObject(result, (bool)0);
38823 }
38824 {
38825 if (temp3)
38826 delete arg3;
38827 }
38828 {
38829 if (temp4)
38830 delete arg4;
38831 }
38832 return resultobj;
38833 fail:
38834 {
38835 if (temp3)
38836 delete arg3;
38837 }
38838 {
38839 if (temp4)
38840 delete arg4;
38841 }
38842 return NULL;
38843 }
38844
38845
38846 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38847 PyObject *resultobj = 0;
38848 wxMenu *arg1 = (wxMenu *) 0 ;
38849 int arg2 ;
38850 wxString *arg3 = 0 ;
38851 wxMenu *arg4 = (wxMenu *) 0 ;
38852 wxString const &arg5_defvalue = wxPyEmptyString ;
38853 wxString *arg5 = (wxString *) &arg5_defvalue ;
38854 wxMenuItem *result = 0 ;
38855 void *argp1 = 0 ;
38856 int res1 = 0 ;
38857 int val2 ;
38858 int ecode2 = 0 ;
38859 bool temp3 = false ;
38860 void *argp4 = 0 ;
38861 int res4 = 0 ;
38862 bool temp5 = false ;
38863 PyObject * obj0 = 0 ;
38864 PyObject * obj1 = 0 ;
38865 PyObject * obj2 = 0 ;
38866 PyObject * obj3 = 0 ;
38867 PyObject * obj4 = 0 ;
38868 char * kwnames[] = {
38869 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38870 };
38871
38872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38874 if (!SWIG_IsOK(res1)) {
38875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38876 }
38877 arg1 = reinterpret_cast< wxMenu * >(argp1);
38878 ecode2 = SWIG_AsVal_int(obj1, &val2);
38879 if (!SWIG_IsOK(ecode2)) {
38880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38881 }
38882 arg2 = static_cast< int >(val2);
38883 {
38884 arg3 = wxString_in_helper(obj2);
38885 if (arg3 == NULL) SWIG_fail;
38886 temp3 = true;
38887 }
38888 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38889 if (!SWIG_IsOK(res4)) {
38890 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38891 }
38892 arg4 = reinterpret_cast< wxMenu * >(argp4);
38893 if (obj4) {
38894 {
38895 arg5 = wxString_in_helper(obj4);
38896 if (arg5 == NULL) SWIG_fail;
38897 temp5 = true;
38898 }
38899 }
38900 {
38901 PyThreadState* __tstate = wxPyBeginAllowThreads();
38902 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 {
38907 resultobj = wxPyMake_wxObject(result, (bool)0);
38908 }
38909 {
38910 if (temp3)
38911 delete arg3;
38912 }
38913 {
38914 if (temp5)
38915 delete arg5;
38916 }
38917 return resultobj;
38918 fail:
38919 {
38920 if (temp3)
38921 delete arg3;
38922 }
38923 {
38924 if (temp5)
38925 delete arg5;
38926 }
38927 return NULL;
38928 }
38929
38930
38931 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38932 PyObject *resultobj = 0;
38933 wxMenu *arg1 = (wxMenu *) 0 ;
38934 wxMenu *arg2 = (wxMenu *) 0 ;
38935 wxString *arg3 = 0 ;
38936 wxString const &arg4_defvalue = wxPyEmptyString ;
38937 wxString *arg4 = (wxString *) &arg4_defvalue ;
38938 wxMenuItem *result = 0 ;
38939 void *argp1 = 0 ;
38940 int res1 = 0 ;
38941 void *argp2 = 0 ;
38942 int res2 = 0 ;
38943 bool temp3 = false ;
38944 bool temp4 = false ;
38945 PyObject * obj0 = 0 ;
38946 PyObject * obj1 = 0 ;
38947 PyObject * obj2 = 0 ;
38948 PyObject * obj3 = 0 ;
38949 char * kwnames[] = {
38950 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38951 };
38952
38953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38955 if (!SWIG_IsOK(res1)) {
38956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38957 }
38958 arg1 = reinterpret_cast< wxMenu * >(argp1);
38959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38960 if (!SWIG_IsOK(res2)) {
38961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38962 }
38963 arg2 = reinterpret_cast< wxMenu * >(argp2);
38964 {
38965 arg3 = wxString_in_helper(obj2);
38966 if (arg3 == NULL) SWIG_fail;
38967 temp3 = true;
38968 }
38969 if (obj3) {
38970 {
38971 arg4 = wxString_in_helper(obj3);
38972 if (arg4 == NULL) SWIG_fail;
38973 temp4 = true;
38974 }
38975 }
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38979 wxPyEndAllowThreads(__tstate);
38980 if (PyErr_Occurred()) SWIG_fail;
38981 }
38982 {
38983 resultobj = wxPyMake_wxObject(result, (bool)0);
38984 }
38985 {
38986 if (temp3)
38987 delete arg3;
38988 }
38989 {
38990 if (temp4)
38991 delete arg4;
38992 }
38993 return resultobj;
38994 fail:
38995 {
38996 if (temp3)
38997 delete arg3;
38998 }
38999 {
39000 if (temp4)
39001 delete arg4;
39002 }
39003 return NULL;
39004 }
39005
39006
39007 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39008 PyObject *resultobj = 0;
39009 wxMenu *arg1 = (wxMenu *) 0 ;
39010 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39011 wxMenuItem *result = 0 ;
39012 void *argp1 = 0 ;
39013 int res1 = 0 ;
39014 int res2 = 0 ;
39015 PyObject * obj0 = 0 ;
39016 PyObject * obj1 = 0 ;
39017 char * kwnames[] = {
39018 (char *) "self",(char *) "item", NULL
39019 };
39020
39021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39023 if (!SWIG_IsOK(res1)) {
39024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39025 }
39026 arg1 = reinterpret_cast< wxMenu * >(argp1);
39027 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39028 if (!SWIG_IsOK(res2)) {
39029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39030 }
39031 {
39032 PyThreadState* __tstate = wxPyBeginAllowThreads();
39033 result = (wxMenuItem *)(arg1)->Append(arg2);
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 {
39038 resultobj = wxPyMake_wxObject(result, (bool)0);
39039 }
39040 return resultobj;
39041 fail:
39042 return NULL;
39043 }
39044
39045
39046 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39047 PyObject *resultobj = 0;
39048 wxMenu *arg1 = (wxMenu *) 0 ;
39049 size_t arg2 ;
39050 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39051 wxMenuItem *result = 0 ;
39052 void *argp1 = 0 ;
39053 int res1 = 0 ;
39054 size_t val2 ;
39055 int ecode2 = 0 ;
39056 int res3 = 0 ;
39057 PyObject * obj0 = 0 ;
39058 PyObject * obj1 = 0 ;
39059 PyObject * obj2 = 0 ;
39060 char * kwnames[] = {
39061 (char *) "self",(char *) "pos",(char *) "item", NULL
39062 };
39063
39064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39066 if (!SWIG_IsOK(res1)) {
39067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39068 }
39069 arg1 = reinterpret_cast< wxMenu * >(argp1);
39070 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39071 if (!SWIG_IsOK(ecode2)) {
39072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39073 }
39074 arg2 = static_cast< size_t >(val2);
39075 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39076 if (!SWIG_IsOK(res3)) {
39077 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39078 }
39079 {
39080 PyThreadState* __tstate = wxPyBeginAllowThreads();
39081 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39082 wxPyEndAllowThreads(__tstate);
39083 if (PyErr_Occurred()) SWIG_fail;
39084 }
39085 {
39086 resultobj = wxPyMake_wxObject(result, (bool)0);
39087 }
39088 return resultobj;
39089 fail:
39090 return NULL;
39091 }
39092
39093
39094 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39095 PyObject *resultobj = 0;
39096 wxMenu *arg1 = (wxMenu *) 0 ;
39097 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39098 wxMenuItem *result = 0 ;
39099 void *argp1 = 0 ;
39100 int res1 = 0 ;
39101 int res2 = 0 ;
39102 PyObject * obj0 = 0 ;
39103 PyObject * obj1 = 0 ;
39104 char * kwnames[] = {
39105 (char *) "self",(char *) "item", NULL
39106 };
39107
39108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39110 if (!SWIG_IsOK(res1)) {
39111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39112 }
39113 arg1 = reinterpret_cast< wxMenu * >(argp1);
39114 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39115 if (!SWIG_IsOK(res2)) {
39116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39117 }
39118 {
39119 PyThreadState* __tstate = wxPyBeginAllowThreads();
39120 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39121 wxPyEndAllowThreads(__tstate);
39122 if (PyErr_Occurred()) SWIG_fail;
39123 }
39124 {
39125 resultobj = wxPyMake_wxObject(result, (bool)0);
39126 }
39127 return resultobj;
39128 fail:
39129 return NULL;
39130 }
39131
39132
39133 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39134 PyObject *resultobj = 0;
39135 wxMenu *arg1 = (wxMenu *) 0 ;
39136 void *argp1 = 0 ;
39137 int res1 = 0 ;
39138 PyObject *swig_obj[1] ;
39139
39140 if (!args) SWIG_fail;
39141 swig_obj[0] = args;
39142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39143 if (!SWIG_IsOK(res1)) {
39144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39145 }
39146 arg1 = reinterpret_cast< wxMenu * >(argp1);
39147 {
39148 PyThreadState* __tstate = wxPyBeginAllowThreads();
39149 (arg1)->Break();
39150 wxPyEndAllowThreads(__tstate);
39151 if (PyErr_Occurred()) SWIG_fail;
39152 }
39153 resultobj = SWIG_Py_Void();
39154 return resultobj;
39155 fail:
39156 return NULL;
39157 }
39158
39159
39160 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39161 PyObject *resultobj = 0;
39162 wxMenu *arg1 = (wxMenu *) 0 ;
39163 size_t arg2 ;
39164 int arg3 ;
39165 wxString *arg4 = 0 ;
39166 wxString const &arg5_defvalue = wxPyEmptyString ;
39167 wxString *arg5 = (wxString *) &arg5_defvalue ;
39168 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39169 wxMenuItem *result = 0 ;
39170 void *argp1 = 0 ;
39171 int res1 = 0 ;
39172 size_t val2 ;
39173 int ecode2 = 0 ;
39174 int val3 ;
39175 int ecode3 = 0 ;
39176 bool temp4 = false ;
39177 bool temp5 = false ;
39178 int val6 ;
39179 int ecode6 = 0 ;
39180 PyObject * obj0 = 0 ;
39181 PyObject * obj1 = 0 ;
39182 PyObject * obj2 = 0 ;
39183 PyObject * obj3 = 0 ;
39184 PyObject * obj4 = 0 ;
39185 PyObject * obj5 = 0 ;
39186 char * kwnames[] = {
39187 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39188 };
39189
39190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39192 if (!SWIG_IsOK(res1)) {
39193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39194 }
39195 arg1 = reinterpret_cast< wxMenu * >(argp1);
39196 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39197 if (!SWIG_IsOK(ecode2)) {
39198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39199 }
39200 arg2 = static_cast< size_t >(val2);
39201 ecode3 = SWIG_AsVal_int(obj2, &val3);
39202 if (!SWIG_IsOK(ecode3)) {
39203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39204 }
39205 arg3 = static_cast< int >(val3);
39206 {
39207 arg4 = wxString_in_helper(obj3);
39208 if (arg4 == NULL) SWIG_fail;
39209 temp4 = true;
39210 }
39211 if (obj4) {
39212 {
39213 arg5 = wxString_in_helper(obj4);
39214 if (arg5 == NULL) SWIG_fail;
39215 temp5 = true;
39216 }
39217 }
39218 if (obj5) {
39219 ecode6 = SWIG_AsVal_int(obj5, &val6);
39220 if (!SWIG_IsOK(ecode6)) {
39221 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39222 }
39223 arg6 = static_cast< wxItemKind >(val6);
39224 }
39225 {
39226 PyThreadState* __tstate = wxPyBeginAllowThreads();
39227 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39228 wxPyEndAllowThreads(__tstate);
39229 if (PyErr_Occurred()) SWIG_fail;
39230 }
39231 {
39232 resultobj = wxPyMake_wxObject(result, (bool)0);
39233 }
39234 {
39235 if (temp4)
39236 delete arg4;
39237 }
39238 {
39239 if (temp5)
39240 delete arg5;
39241 }
39242 return resultobj;
39243 fail:
39244 {
39245 if (temp4)
39246 delete arg4;
39247 }
39248 {
39249 if (temp5)
39250 delete arg5;
39251 }
39252 return NULL;
39253 }
39254
39255
39256 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj = 0;
39258 wxMenu *arg1 = (wxMenu *) 0 ;
39259 size_t arg2 ;
39260 wxMenuItem *result = 0 ;
39261 void *argp1 = 0 ;
39262 int res1 = 0 ;
39263 size_t val2 ;
39264 int ecode2 = 0 ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 char * kwnames[] = {
39268 (char *) "self",(char *) "pos", NULL
39269 };
39270
39271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39273 if (!SWIG_IsOK(res1)) {
39274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39275 }
39276 arg1 = reinterpret_cast< wxMenu * >(argp1);
39277 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39278 if (!SWIG_IsOK(ecode2)) {
39279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39280 }
39281 arg2 = static_cast< size_t >(val2);
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, (bool)0);
39290 }
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj = 0;
39299 wxMenu *arg1 = (wxMenu *) 0 ;
39300 size_t arg2 ;
39301 int arg3 ;
39302 wxString *arg4 = 0 ;
39303 wxString const &arg5_defvalue = wxPyEmptyString ;
39304 wxString *arg5 = (wxString *) &arg5_defvalue ;
39305 wxMenuItem *result = 0 ;
39306 void *argp1 = 0 ;
39307 int res1 = 0 ;
39308 size_t val2 ;
39309 int ecode2 = 0 ;
39310 int val3 ;
39311 int ecode3 = 0 ;
39312 bool temp4 = false ;
39313 bool temp5 = false ;
39314 PyObject * obj0 = 0 ;
39315 PyObject * obj1 = 0 ;
39316 PyObject * obj2 = 0 ;
39317 PyObject * obj3 = 0 ;
39318 PyObject * obj4 = 0 ;
39319 char * kwnames[] = {
39320 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39321 };
39322
39323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39325 if (!SWIG_IsOK(res1)) {
39326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39327 }
39328 arg1 = reinterpret_cast< wxMenu * >(argp1);
39329 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39330 if (!SWIG_IsOK(ecode2)) {
39331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39332 }
39333 arg2 = static_cast< size_t >(val2);
39334 ecode3 = SWIG_AsVal_int(obj2, &val3);
39335 if (!SWIG_IsOK(ecode3)) {
39336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39337 }
39338 arg3 = static_cast< int >(val3);
39339 {
39340 arg4 = wxString_in_helper(obj3);
39341 if (arg4 == NULL) SWIG_fail;
39342 temp4 = true;
39343 }
39344 if (obj4) {
39345 {
39346 arg5 = wxString_in_helper(obj4);
39347 if (arg5 == NULL) SWIG_fail;
39348 temp5 = true;
39349 }
39350 }
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39354 wxPyEndAllowThreads(__tstate);
39355 if (PyErr_Occurred()) SWIG_fail;
39356 }
39357 {
39358 resultobj = wxPyMake_wxObject(result, (bool)0);
39359 }
39360 {
39361 if (temp4)
39362 delete arg4;
39363 }
39364 {
39365 if (temp5)
39366 delete arg5;
39367 }
39368 return resultobj;
39369 fail:
39370 {
39371 if (temp4)
39372 delete arg4;
39373 }
39374 {
39375 if (temp5)
39376 delete arg5;
39377 }
39378 return NULL;
39379 }
39380
39381
39382 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39383 PyObject *resultobj = 0;
39384 wxMenu *arg1 = (wxMenu *) 0 ;
39385 size_t arg2 ;
39386 int arg3 ;
39387 wxString *arg4 = 0 ;
39388 wxString const &arg5_defvalue = wxPyEmptyString ;
39389 wxString *arg5 = (wxString *) &arg5_defvalue ;
39390 wxMenuItem *result = 0 ;
39391 void *argp1 = 0 ;
39392 int res1 = 0 ;
39393 size_t val2 ;
39394 int ecode2 = 0 ;
39395 int val3 ;
39396 int ecode3 = 0 ;
39397 bool temp4 = false ;
39398 bool temp5 = false ;
39399 PyObject * obj0 = 0 ;
39400 PyObject * obj1 = 0 ;
39401 PyObject * obj2 = 0 ;
39402 PyObject * obj3 = 0 ;
39403 PyObject * obj4 = 0 ;
39404 char * kwnames[] = {
39405 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39406 };
39407
39408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39410 if (!SWIG_IsOK(res1)) {
39411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39412 }
39413 arg1 = reinterpret_cast< wxMenu * >(argp1);
39414 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39415 if (!SWIG_IsOK(ecode2)) {
39416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39417 }
39418 arg2 = static_cast< size_t >(val2);
39419 ecode3 = SWIG_AsVal_int(obj2, &val3);
39420 if (!SWIG_IsOK(ecode3)) {
39421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39422 }
39423 arg3 = static_cast< int >(val3);
39424 {
39425 arg4 = wxString_in_helper(obj3);
39426 if (arg4 == NULL) SWIG_fail;
39427 temp4 = true;
39428 }
39429 if (obj4) {
39430 {
39431 arg5 = wxString_in_helper(obj4);
39432 if (arg5 == NULL) SWIG_fail;
39433 temp5 = true;
39434 }
39435 }
39436 {
39437 PyThreadState* __tstate = wxPyBeginAllowThreads();
39438 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39439 wxPyEndAllowThreads(__tstate);
39440 if (PyErr_Occurred()) SWIG_fail;
39441 }
39442 {
39443 resultobj = wxPyMake_wxObject(result, (bool)0);
39444 }
39445 {
39446 if (temp4)
39447 delete arg4;
39448 }
39449 {
39450 if (temp5)
39451 delete arg5;
39452 }
39453 return resultobj;
39454 fail:
39455 {
39456 if (temp4)
39457 delete arg4;
39458 }
39459 {
39460 if (temp5)
39461 delete arg5;
39462 }
39463 return NULL;
39464 }
39465
39466
39467 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39468 PyObject *resultobj = 0;
39469 wxMenu *arg1 = (wxMenu *) 0 ;
39470 size_t arg2 ;
39471 int arg3 ;
39472 wxString *arg4 = 0 ;
39473 wxMenu *arg5 = (wxMenu *) 0 ;
39474 wxString const &arg6_defvalue = wxPyEmptyString ;
39475 wxString *arg6 = (wxString *) &arg6_defvalue ;
39476 wxMenuItem *result = 0 ;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 size_t val2 ;
39480 int ecode2 = 0 ;
39481 int val3 ;
39482 int ecode3 = 0 ;
39483 bool temp4 = false ;
39484 void *argp5 = 0 ;
39485 int res5 = 0 ;
39486 bool temp6 = false ;
39487 PyObject * obj0 = 0 ;
39488 PyObject * obj1 = 0 ;
39489 PyObject * obj2 = 0 ;
39490 PyObject * obj3 = 0 ;
39491 PyObject * obj4 = 0 ;
39492 PyObject * obj5 = 0 ;
39493 char * kwnames[] = {
39494 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39495 };
39496
39497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39499 if (!SWIG_IsOK(res1)) {
39500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39501 }
39502 arg1 = reinterpret_cast< wxMenu * >(argp1);
39503 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39504 if (!SWIG_IsOK(ecode2)) {
39505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39506 }
39507 arg2 = static_cast< size_t >(val2);
39508 ecode3 = SWIG_AsVal_int(obj2, &val3);
39509 if (!SWIG_IsOK(ecode3)) {
39510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39511 }
39512 arg3 = static_cast< int >(val3);
39513 {
39514 arg4 = wxString_in_helper(obj3);
39515 if (arg4 == NULL) SWIG_fail;
39516 temp4 = true;
39517 }
39518 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39519 if (!SWIG_IsOK(res5)) {
39520 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39521 }
39522 arg5 = reinterpret_cast< wxMenu * >(argp5);
39523 if (obj5) {
39524 {
39525 arg6 = wxString_in_helper(obj5);
39526 if (arg6 == NULL) SWIG_fail;
39527 temp6 = true;
39528 }
39529 }
39530 {
39531 PyThreadState* __tstate = wxPyBeginAllowThreads();
39532 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39533 wxPyEndAllowThreads(__tstate);
39534 if (PyErr_Occurred()) SWIG_fail;
39535 }
39536 {
39537 resultobj = wxPyMake_wxObject(result, (bool)0);
39538 }
39539 {
39540 if (temp4)
39541 delete arg4;
39542 }
39543 {
39544 if (temp6)
39545 delete arg6;
39546 }
39547 return resultobj;
39548 fail:
39549 {
39550 if (temp4)
39551 delete arg4;
39552 }
39553 {
39554 if (temp6)
39555 delete arg6;
39556 }
39557 return NULL;
39558 }
39559
39560
39561 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39562 PyObject *resultobj = 0;
39563 wxMenu *arg1 = (wxMenu *) 0 ;
39564 int arg2 ;
39565 wxString *arg3 = 0 ;
39566 wxString const &arg4_defvalue = wxPyEmptyString ;
39567 wxString *arg4 = (wxString *) &arg4_defvalue ;
39568 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39569 wxMenuItem *result = 0 ;
39570 void *argp1 = 0 ;
39571 int res1 = 0 ;
39572 int val2 ;
39573 int ecode2 = 0 ;
39574 bool temp3 = false ;
39575 bool temp4 = false ;
39576 int val5 ;
39577 int ecode5 = 0 ;
39578 PyObject * obj0 = 0 ;
39579 PyObject * obj1 = 0 ;
39580 PyObject * obj2 = 0 ;
39581 PyObject * obj3 = 0 ;
39582 PyObject * obj4 = 0 ;
39583 char * kwnames[] = {
39584 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39585 };
39586
39587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39589 if (!SWIG_IsOK(res1)) {
39590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39591 }
39592 arg1 = reinterpret_cast< wxMenu * >(argp1);
39593 ecode2 = SWIG_AsVal_int(obj1, &val2);
39594 if (!SWIG_IsOK(ecode2)) {
39595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39596 }
39597 arg2 = static_cast< int >(val2);
39598 {
39599 arg3 = wxString_in_helper(obj2);
39600 if (arg3 == NULL) SWIG_fail;
39601 temp3 = true;
39602 }
39603 if (obj3) {
39604 {
39605 arg4 = wxString_in_helper(obj3);
39606 if (arg4 == NULL) SWIG_fail;
39607 temp4 = true;
39608 }
39609 }
39610 if (obj4) {
39611 ecode5 = SWIG_AsVal_int(obj4, &val5);
39612 if (!SWIG_IsOK(ecode5)) {
39613 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39614 }
39615 arg5 = static_cast< wxItemKind >(val5);
39616 }
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39620 wxPyEndAllowThreads(__tstate);
39621 if (PyErr_Occurred()) SWIG_fail;
39622 }
39623 {
39624 resultobj = wxPyMake_wxObject(result, (bool)0);
39625 }
39626 {
39627 if (temp3)
39628 delete arg3;
39629 }
39630 {
39631 if (temp4)
39632 delete arg4;
39633 }
39634 return resultobj;
39635 fail:
39636 {
39637 if (temp3)
39638 delete arg3;
39639 }
39640 {
39641 if (temp4)
39642 delete arg4;
39643 }
39644 return NULL;
39645 }
39646
39647
39648 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39649 PyObject *resultobj = 0;
39650 wxMenu *arg1 = (wxMenu *) 0 ;
39651 wxMenuItem *result = 0 ;
39652 void *argp1 = 0 ;
39653 int res1 = 0 ;
39654 PyObject *swig_obj[1] ;
39655
39656 if (!args) SWIG_fail;
39657 swig_obj[0] = args;
39658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39659 if (!SWIG_IsOK(res1)) {
39660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39661 }
39662 arg1 = reinterpret_cast< wxMenu * >(argp1);
39663 {
39664 PyThreadState* __tstate = wxPyBeginAllowThreads();
39665 result = (wxMenuItem *)(arg1)->PrependSeparator();
39666 wxPyEndAllowThreads(__tstate);
39667 if (PyErr_Occurred()) SWIG_fail;
39668 }
39669 {
39670 resultobj = wxPyMake_wxObject(result, (bool)0);
39671 }
39672 return resultobj;
39673 fail:
39674 return NULL;
39675 }
39676
39677
39678 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39679 PyObject *resultobj = 0;
39680 wxMenu *arg1 = (wxMenu *) 0 ;
39681 int arg2 ;
39682 wxString *arg3 = 0 ;
39683 wxString const &arg4_defvalue = wxPyEmptyString ;
39684 wxString *arg4 = (wxString *) &arg4_defvalue ;
39685 wxMenuItem *result = 0 ;
39686 void *argp1 = 0 ;
39687 int res1 = 0 ;
39688 int val2 ;
39689 int ecode2 = 0 ;
39690 bool temp3 = false ;
39691 bool temp4 = false ;
39692 PyObject * obj0 = 0 ;
39693 PyObject * obj1 = 0 ;
39694 PyObject * obj2 = 0 ;
39695 PyObject * obj3 = 0 ;
39696 char * kwnames[] = {
39697 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39698 };
39699
39700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39702 if (!SWIG_IsOK(res1)) {
39703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39704 }
39705 arg1 = reinterpret_cast< wxMenu * >(argp1);
39706 ecode2 = SWIG_AsVal_int(obj1, &val2);
39707 if (!SWIG_IsOK(ecode2)) {
39708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39709 }
39710 arg2 = static_cast< int >(val2);
39711 {
39712 arg3 = wxString_in_helper(obj2);
39713 if (arg3 == NULL) SWIG_fail;
39714 temp3 = true;
39715 }
39716 if (obj3) {
39717 {
39718 arg4 = wxString_in_helper(obj3);
39719 if (arg4 == NULL) SWIG_fail;
39720 temp4 = true;
39721 }
39722 }
39723 {
39724 PyThreadState* __tstate = wxPyBeginAllowThreads();
39725 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 {
39730 resultobj = wxPyMake_wxObject(result, (bool)0);
39731 }
39732 {
39733 if (temp3)
39734 delete arg3;
39735 }
39736 {
39737 if (temp4)
39738 delete arg4;
39739 }
39740 return resultobj;
39741 fail:
39742 {
39743 if (temp3)
39744 delete arg3;
39745 }
39746 {
39747 if (temp4)
39748 delete arg4;
39749 }
39750 return NULL;
39751 }
39752
39753
39754 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39755 PyObject *resultobj = 0;
39756 wxMenu *arg1 = (wxMenu *) 0 ;
39757 int arg2 ;
39758 wxString *arg3 = 0 ;
39759 wxString const &arg4_defvalue = wxPyEmptyString ;
39760 wxString *arg4 = (wxString *) &arg4_defvalue ;
39761 wxMenuItem *result = 0 ;
39762 void *argp1 = 0 ;
39763 int res1 = 0 ;
39764 int val2 ;
39765 int ecode2 = 0 ;
39766 bool temp3 = false ;
39767 bool temp4 = false ;
39768 PyObject * obj0 = 0 ;
39769 PyObject * obj1 = 0 ;
39770 PyObject * obj2 = 0 ;
39771 PyObject * obj3 = 0 ;
39772 char * kwnames[] = {
39773 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39774 };
39775
39776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39778 if (!SWIG_IsOK(res1)) {
39779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39780 }
39781 arg1 = reinterpret_cast< wxMenu * >(argp1);
39782 ecode2 = SWIG_AsVal_int(obj1, &val2);
39783 if (!SWIG_IsOK(ecode2)) {
39784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39785 }
39786 arg2 = static_cast< int >(val2);
39787 {
39788 arg3 = wxString_in_helper(obj2);
39789 if (arg3 == NULL) SWIG_fail;
39790 temp3 = true;
39791 }
39792 if (obj3) {
39793 {
39794 arg4 = wxString_in_helper(obj3);
39795 if (arg4 == NULL) SWIG_fail;
39796 temp4 = true;
39797 }
39798 }
39799 {
39800 PyThreadState* __tstate = wxPyBeginAllowThreads();
39801 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39802 wxPyEndAllowThreads(__tstate);
39803 if (PyErr_Occurred()) SWIG_fail;
39804 }
39805 {
39806 resultobj = wxPyMake_wxObject(result, (bool)0);
39807 }
39808 {
39809 if (temp3)
39810 delete arg3;
39811 }
39812 {
39813 if (temp4)
39814 delete arg4;
39815 }
39816 return resultobj;
39817 fail:
39818 {
39819 if (temp3)
39820 delete arg3;
39821 }
39822 {
39823 if (temp4)
39824 delete arg4;
39825 }
39826 return NULL;
39827 }
39828
39829
39830 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39831 PyObject *resultobj = 0;
39832 wxMenu *arg1 = (wxMenu *) 0 ;
39833 int arg2 ;
39834 wxString *arg3 = 0 ;
39835 wxMenu *arg4 = (wxMenu *) 0 ;
39836 wxString const &arg5_defvalue = wxPyEmptyString ;
39837 wxString *arg5 = (wxString *) &arg5_defvalue ;
39838 wxMenuItem *result = 0 ;
39839 void *argp1 = 0 ;
39840 int res1 = 0 ;
39841 int val2 ;
39842 int ecode2 = 0 ;
39843 bool temp3 = false ;
39844 void *argp4 = 0 ;
39845 int res4 = 0 ;
39846 bool temp5 = false ;
39847 PyObject * obj0 = 0 ;
39848 PyObject * obj1 = 0 ;
39849 PyObject * obj2 = 0 ;
39850 PyObject * obj3 = 0 ;
39851 PyObject * obj4 = 0 ;
39852 char * kwnames[] = {
39853 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39854 };
39855
39856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39858 if (!SWIG_IsOK(res1)) {
39859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39860 }
39861 arg1 = reinterpret_cast< wxMenu * >(argp1);
39862 ecode2 = SWIG_AsVal_int(obj1, &val2);
39863 if (!SWIG_IsOK(ecode2)) {
39864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39865 }
39866 arg2 = static_cast< int >(val2);
39867 {
39868 arg3 = wxString_in_helper(obj2);
39869 if (arg3 == NULL) SWIG_fail;
39870 temp3 = true;
39871 }
39872 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39873 if (!SWIG_IsOK(res4)) {
39874 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39875 }
39876 arg4 = reinterpret_cast< wxMenu * >(argp4);
39877 if (obj4) {
39878 {
39879 arg5 = wxString_in_helper(obj4);
39880 if (arg5 == NULL) SWIG_fail;
39881 temp5 = true;
39882 }
39883 }
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 {
39891 resultobj = wxPyMake_wxObject(result, (bool)0);
39892 }
39893 {
39894 if (temp3)
39895 delete arg3;
39896 }
39897 {
39898 if (temp5)
39899 delete arg5;
39900 }
39901 return resultobj;
39902 fail:
39903 {
39904 if (temp3)
39905 delete arg3;
39906 }
39907 {
39908 if (temp5)
39909 delete arg5;
39910 }
39911 return NULL;
39912 }
39913
39914
39915 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj = 0;
39917 wxMenu *arg1 = (wxMenu *) 0 ;
39918 int arg2 ;
39919 wxMenuItem *result = 0 ;
39920 void *argp1 = 0 ;
39921 int res1 = 0 ;
39922 int val2 ;
39923 int ecode2 = 0 ;
39924 PyObject * obj0 = 0 ;
39925 PyObject * obj1 = 0 ;
39926 char * kwnames[] = {
39927 (char *) "self",(char *) "id", NULL
39928 };
39929
39930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39932 if (!SWIG_IsOK(res1)) {
39933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39934 }
39935 arg1 = reinterpret_cast< wxMenu * >(argp1);
39936 ecode2 = SWIG_AsVal_int(obj1, &val2);
39937 if (!SWIG_IsOK(ecode2)) {
39938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39939 }
39940 arg2 = static_cast< int >(val2);
39941 {
39942 PyThreadState* __tstate = wxPyBeginAllowThreads();
39943 result = (wxMenuItem *)(arg1)->Remove(arg2);
39944 wxPyEndAllowThreads(__tstate);
39945 if (PyErr_Occurred()) SWIG_fail;
39946 }
39947 {
39948 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39949 }
39950 return resultobj;
39951 fail:
39952 return NULL;
39953 }
39954
39955
39956 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39957 PyObject *resultobj = 0;
39958 wxMenu *arg1 = (wxMenu *) 0 ;
39959 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39960 wxMenuItem *result = 0 ;
39961 void *argp1 = 0 ;
39962 int res1 = 0 ;
39963 void *argp2 = 0 ;
39964 int res2 = 0 ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 char * kwnames[] = {
39968 (char *) "self",(char *) "item", NULL
39969 };
39970
39971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39973 if (!SWIG_IsOK(res1)) {
39974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39975 }
39976 arg1 = reinterpret_cast< wxMenu * >(argp1);
39977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39978 if (!SWIG_IsOK(res2)) {
39979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39980 }
39981 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 result = (wxMenuItem *)(arg1)->Remove(arg2);
39985 wxPyEndAllowThreads(__tstate);
39986 if (PyErr_Occurred()) SWIG_fail;
39987 }
39988 {
39989 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39990 }
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj = 0;
39999 wxMenu *arg1 = (wxMenu *) 0 ;
40000 int arg2 ;
40001 bool result;
40002 void *argp1 = 0 ;
40003 int res1 = 0 ;
40004 int val2 ;
40005 int ecode2 = 0 ;
40006 PyObject * obj0 = 0 ;
40007 PyObject * obj1 = 0 ;
40008 char * kwnames[] = {
40009 (char *) "self",(char *) "id", NULL
40010 };
40011
40012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40014 if (!SWIG_IsOK(res1)) {
40015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40016 }
40017 arg1 = reinterpret_cast< wxMenu * >(argp1);
40018 ecode2 = SWIG_AsVal_int(obj1, &val2);
40019 if (!SWIG_IsOK(ecode2)) {
40020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40021 }
40022 arg2 = static_cast< int >(val2);
40023 {
40024 PyThreadState* __tstate = wxPyBeginAllowThreads();
40025 result = (bool)(arg1)->Delete(arg2);
40026 wxPyEndAllowThreads(__tstate);
40027 if (PyErr_Occurred()) SWIG_fail;
40028 }
40029 {
40030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40031 }
40032 return resultobj;
40033 fail:
40034 return NULL;
40035 }
40036
40037
40038 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40039 PyObject *resultobj = 0;
40040 wxMenu *arg1 = (wxMenu *) 0 ;
40041 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40042 bool result;
40043 void *argp1 = 0 ;
40044 int res1 = 0 ;
40045 void *argp2 = 0 ;
40046 int res2 = 0 ;
40047 PyObject * obj0 = 0 ;
40048 PyObject * obj1 = 0 ;
40049 char * kwnames[] = {
40050 (char *) "self",(char *) "item", NULL
40051 };
40052
40053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40055 if (!SWIG_IsOK(res1)) {
40056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40057 }
40058 arg1 = reinterpret_cast< wxMenu * >(argp1);
40059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40060 if (!SWIG_IsOK(res2)) {
40061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40062 }
40063 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40064 {
40065 PyThreadState* __tstate = wxPyBeginAllowThreads();
40066 result = (bool)(arg1)->Delete(arg2);
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 {
40071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40072 }
40073 return resultobj;
40074 fail:
40075 return NULL;
40076 }
40077
40078
40079 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40080 PyObject *resultobj = 0;
40081 wxMenu *arg1 = (wxMenu *) 0 ;
40082 void *argp1 = 0 ;
40083 int res1 = 0 ;
40084 PyObject *swig_obj[1] ;
40085
40086 if (!args) SWIG_fail;
40087 swig_obj[0] = args;
40088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40089 if (!SWIG_IsOK(res1)) {
40090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40091 }
40092 arg1 = reinterpret_cast< wxMenu * >(argp1);
40093 {
40094 PyThreadState* __tstate = wxPyBeginAllowThreads();
40095 wxMenu_Destroy(arg1);
40096 wxPyEndAllowThreads(__tstate);
40097 if (PyErr_Occurred()) SWIG_fail;
40098 }
40099 resultobj = SWIG_Py_Void();
40100 return resultobj;
40101 fail:
40102 return NULL;
40103 }
40104
40105
40106 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40107 PyObject *resultobj = 0;
40108 wxMenu *arg1 = (wxMenu *) 0 ;
40109 int arg2 ;
40110 bool result;
40111 void *argp1 = 0 ;
40112 int res1 = 0 ;
40113 int val2 ;
40114 int ecode2 = 0 ;
40115 PyObject * obj0 = 0 ;
40116 PyObject * obj1 = 0 ;
40117 char * kwnames[] = {
40118 (char *) "self",(char *) "id", NULL
40119 };
40120
40121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40123 if (!SWIG_IsOK(res1)) {
40124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40125 }
40126 arg1 = reinterpret_cast< wxMenu * >(argp1);
40127 ecode2 = SWIG_AsVal_int(obj1, &val2);
40128 if (!SWIG_IsOK(ecode2)) {
40129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40130 }
40131 arg2 = static_cast< int >(val2);
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 result = (bool)(arg1)->Destroy(arg2);
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 {
40139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40140 }
40141 return resultobj;
40142 fail:
40143 return NULL;
40144 }
40145
40146
40147 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40148 PyObject *resultobj = 0;
40149 wxMenu *arg1 = (wxMenu *) 0 ;
40150 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40151 bool result;
40152 void *argp1 = 0 ;
40153 int res1 = 0 ;
40154 void *argp2 = 0 ;
40155 int res2 = 0 ;
40156 PyObject * obj0 = 0 ;
40157 PyObject * obj1 = 0 ;
40158 char * kwnames[] = {
40159 (char *) "self",(char *) "item", NULL
40160 };
40161
40162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40164 if (!SWIG_IsOK(res1)) {
40165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40166 }
40167 arg1 = reinterpret_cast< wxMenu * >(argp1);
40168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40169 if (!SWIG_IsOK(res2)) {
40170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40171 }
40172 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40173 {
40174 PyThreadState* __tstate = wxPyBeginAllowThreads();
40175 result = (bool)(arg1)->Destroy(arg2);
40176 wxPyEndAllowThreads(__tstate);
40177 if (PyErr_Occurred()) SWIG_fail;
40178 }
40179 {
40180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40181 }
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40189 PyObject *resultobj = 0;
40190 wxMenu *arg1 = (wxMenu *) 0 ;
40191 size_t result;
40192 void *argp1 = 0 ;
40193 int res1 = 0 ;
40194 PyObject *swig_obj[1] ;
40195
40196 if (!args) SWIG_fail;
40197 swig_obj[0] = args;
40198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40199 if (!SWIG_IsOK(res1)) {
40200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40201 }
40202 arg1 = reinterpret_cast< wxMenu * >(argp1);
40203 {
40204 PyThreadState* __tstate = wxPyBeginAllowThreads();
40205 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40206 wxPyEndAllowThreads(__tstate);
40207 if (PyErr_Occurred()) SWIG_fail;
40208 }
40209 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40210 return resultobj;
40211 fail:
40212 return NULL;
40213 }
40214
40215
40216 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40217 PyObject *resultobj = 0;
40218 wxMenu *arg1 = (wxMenu *) 0 ;
40219 PyObject *result = 0 ;
40220 void *argp1 = 0 ;
40221 int res1 = 0 ;
40222 PyObject *swig_obj[1] ;
40223
40224 if (!args) SWIG_fail;
40225 swig_obj[0] = args;
40226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40227 if (!SWIG_IsOK(res1)) {
40228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40229 }
40230 arg1 = reinterpret_cast< wxMenu * >(argp1);
40231 {
40232 PyThreadState* __tstate = wxPyBeginAllowThreads();
40233 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40234 wxPyEndAllowThreads(__tstate);
40235 if (PyErr_Occurred()) SWIG_fail;
40236 }
40237 resultobj = result;
40238 return resultobj;
40239 fail:
40240 return NULL;
40241 }
40242
40243
40244 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40245 PyObject *resultobj = 0;
40246 wxMenu *arg1 = (wxMenu *) 0 ;
40247 wxString *arg2 = 0 ;
40248 int result;
40249 void *argp1 = 0 ;
40250 int res1 = 0 ;
40251 bool temp2 = false ;
40252 PyObject * obj0 = 0 ;
40253 PyObject * obj1 = 0 ;
40254 char * kwnames[] = {
40255 (char *) "self",(char *) "item", NULL
40256 };
40257
40258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40260 if (!SWIG_IsOK(res1)) {
40261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40262 }
40263 arg1 = reinterpret_cast< wxMenu * >(argp1);
40264 {
40265 arg2 = wxString_in_helper(obj1);
40266 if (arg2 == NULL) SWIG_fail;
40267 temp2 = true;
40268 }
40269 {
40270 PyThreadState* __tstate = wxPyBeginAllowThreads();
40271 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40272 wxPyEndAllowThreads(__tstate);
40273 if (PyErr_Occurred()) SWIG_fail;
40274 }
40275 resultobj = SWIG_From_int(static_cast< int >(result));
40276 {
40277 if (temp2)
40278 delete arg2;
40279 }
40280 return resultobj;
40281 fail:
40282 {
40283 if (temp2)
40284 delete arg2;
40285 }
40286 return NULL;
40287 }
40288
40289
40290 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40291 PyObject *resultobj = 0;
40292 wxMenu *arg1 = (wxMenu *) 0 ;
40293 int arg2 ;
40294 wxMenuItem *result = 0 ;
40295 void *argp1 = 0 ;
40296 int res1 = 0 ;
40297 int val2 ;
40298 int ecode2 = 0 ;
40299 PyObject * obj0 = 0 ;
40300 PyObject * obj1 = 0 ;
40301 char * kwnames[] = {
40302 (char *) "self",(char *) "id", NULL
40303 };
40304
40305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40307 if (!SWIG_IsOK(res1)) {
40308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40309 }
40310 arg1 = reinterpret_cast< wxMenu * >(argp1);
40311 ecode2 = SWIG_AsVal_int(obj1, &val2);
40312 if (!SWIG_IsOK(ecode2)) {
40313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40314 }
40315 arg2 = static_cast< int >(val2);
40316 {
40317 PyThreadState* __tstate = wxPyBeginAllowThreads();
40318 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40319 wxPyEndAllowThreads(__tstate);
40320 if (PyErr_Occurred()) SWIG_fail;
40321 }
40322 {
40323 resultobj = wxPyMake_wxObject(result, (bool)0);
40324 }
40325 return resultobj;
40326 fail:
40327 return NULL;
40328 }
40329
40330
40331 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40332 PyObject *resultobj = 0;
40333 wxMenu *arg1 = (wxMenu *) 0 ;
40334 size_t arg2 ;
40335 wxMenuItem *result = 0 ;
40336 void *argp1 = 0 ;
40337 int res1 = 0 ;
40338 size_t val2 ;
40339 int ecode2 = 0 ;
40340 PyObject * obj0 = 0 ;
40341 PyObject * obj1 = 0 ;
40342 char * kwnames[] = {
40343 (char *) "self",(char *) "position", NULL
40344 };
40345
40346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40348 if (!SWIG_IsOK(res1)) {
40349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40350 }
40351 arg1 = reinterpret_cast< wxMenu * >(argp1);
40352 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40353 if (!SWIG_IsOK(ecode2)) {
40354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40355 }
40356 arg2 = static_cast< size_t >(val2);
40357 {
40358 PyThreadState* __tstate = wxPyBeginAllowThreads();
40359 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40360 wxPyEndAllowThreads(__tstate);
40361 if (PyErr_Occurred()) SWIG_fail;
40362 }
40363 {
40364 resultobj = wxPyMake_wxObject(result, (bool)0);
40365 }
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40373 PyObject *resultobj = 0;
40374 wxMenu *arg1 = (wxMenu *) 0 ;
40375 int arg2 ;
40376 bool arg3 ;
40377 void *argp1 = 0 ;
40378 int res1 = 0 ;
40379 int val2 ;
40380 int ecode2 = 0 ;
40381 bool val3 ;
40382 int ecode3 = 0 ;
40383 PyObject * obj0 = 0 ;
40384 PyObject * obj1 = 0 ;
40385 PyObject * obj2 = 0 ;
40386 char * kwnames[] = {
40387 (char *) "self",(char *) "id",(char *) "enable", NULL
40388 };
40389
40390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40392 if (!SWIG_IsOK(res1)) {
40393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40394 }
40395 arg1 = reinterpret_cast< wxMenu * >(argp1);
40396 ecode2 = SWIG_AsVal_int(obj1, &val2);
40397 if (!SWIG_IsOK(ecode2)) {
40398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40399 }
40400 arg2 = static_cast< int >(val2);
40401 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40402 if (!SWIG_IsOK(ecode3)) {
40403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40404 }
40405 arg3 = static_cast< bool >(val3);
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 (arg1)->Enable(arg2,arg3);
40409 wxPyEndAllowThreads(__tstate);
40410 if (PyErr_Occurred()) SWIG_fail;
40411 }
40412 resultobj = SWIG_Py_Void();
40413 return resultobj;
40414 fail:
40415 return NULL;
40416 }
40417
40418
40419 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40420 PyObject *resultobj = 0;
40421 wxMenu *arg1 = (wxMenu *) 0 ;
40422 int arg2 ;
40423 bool result;
40424 void *argp1 = 0 ;
40425 int res1 = 0 ;
40426 int val2 ;
40427 int ecode2 = 0 ;
40428 PyObject * obj0 = 0 ;
40429 PyObject * obj1 = 0 ;
40430 char * kwnames[] = {
40431 (char *) "self",(char *) "id", NULL
40432 };
40433
40434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40436 if (!SWIG_IsOK(res1)) {
40437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40438 }
40439 arg1 = reinterpret_cast< wxMenu * >(argp1);
40440 ecode2 = SWIG_AsVal_int(obj1, &val2);
40441 if (!SWIG_IsOK(ecode2)) {
40442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40443 }
40444 arg2 = static_cast< int >(val2);
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40448 wxPyEndAllowThreads(__tstate);
40449 if (PyErr_Occurred()) SWIG_fail;
40450 }
40451 {
40452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40453 }
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40461 PyObject *resultobj = 0;
40462 wxMenu *arg1 = (wxMenu *) 0 ;
40463 int arg2 ;
40464 bool arg3 ;
40465 void *argp1 = 0 ;
40466 int res1 = 0 ;
40467 int val2 ;
40468 int ecode2 = 0 ;
40469 bool val3 ;
40470 int ecode3 = 0 ;
40471 PyObject * obj0 = 0 ;
40472 PyObject * obj1 = 0 ;
40473 PyObject * obj2 = 0 ;
40474 char * kwnames[] = {
40475 (char *) "self",(char *) "id",(char *) "check", NULL
40476 };
40477
40478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40480 if (!SWIG_IsOK(res1)) {
40481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40482 }
40483 arg1 = reinterpret_cast< wxMenu * >(argp1);
40484 ecode2 = SWIG_AsVal_int(obj1, &val2);
40485 if (!SWIG_IsOK(ecode2)) {
40486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40487 }
40488 arg2 = static_cast< int >(val2);
40489 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40490 if (!SWIG_IsOK(ecode3)) {
40491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40492 }
40493 arg3 = static_cast< bool >(val3);
40494 {
40495 PyThreadState* __tstate = wxPyBeginAllowThreads();
40496 (arg1)->Check(arg2,arg3);
40497 wxPyEndAllowThreads(__tstate);
40498 if (PyErr_Occurred()) SWIG_fail;
40499 }
40500 resultobj = SWIG_Py_Void();
40501 return resultobj;
40502 fail:
40503 return NULL;
40504 }
40505
40506
40507 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40508 PyObject *resultobj = 0;
40509 wxMenu *arg1 = (wxMenu *) 0 ;
40510 int arg2 ;
40511 bool result;
40512 void *argp1 = 0 ;
40513 int res1 = 0 ;
40514 int val2 ;
40515 int ecode2 = 0 ;
40516 PyObject * obj0 = 0 ;
40517 PyObject * obj1 = 0 ;
40518 char * kwnames[] = {
40519 (char *) "self",(char *) "id", NULL
40520 };
40521
40522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40524 if (!SWIG_IsOK(res1)) {
40525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40526 }
40527 arg1 = reinterpret_cast< wxMenu * >(argp1);
40528 ecode2 = SWIG_AsVal_int(obj1, &val2);
40529 if (!SWIG_IsOK(ecode2)) {
40530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40531 }
40532 arg2 = static_cast< int >(val2);
40533 {
40534 PyThreadState* __tstate = wxPyBeginAllowThreads();
40535 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40536 wxPyEndAllowThreads(__tstate);
40537 if (PyErr_Occurred()) SWIG_fail;
40538 }
40539 {
40540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40541 }
40542 return resultobj;
40543 fail:
40544 return NULL;
40545 }
40546
40547
40548 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40549 PyObject *resultobj = 0;
40550 wxMenu *arg1 = (wxMenu *) 0 ;
40551 int arg2 ;
40552 wxString *arg3 = 0 ;
40553 void *argp1 = 0 ;
40554 int res1 = 0 ;
40555 int val2 ;
40556 int ecode2 = 0 ;
40557 bool temp3 = false ;
40558 PyObject * obj0 = 0 ;
40559 PyObject * obj1 = 0 ;
40560 PyObject * obj2 = 0 ;
40561 char * kwnames[] = {
40562 (char *) "self",(char *) "id",(char *) "label", NULL
40563 };
40564
40565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40567 if (!SWIG_IsOK(res1)) {
40568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40569 }
40570 arg1 = reinterpret_cast< wxMenu * >(argp1);
40571 ecode2 = SWIG_AsVal_int(obj1, &val2);
40572 if (!SWIG_IsOK(ecode2)) {
40573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40574 }
40575 arg2 = static_cast< int >(val2);
40576 {
40577 arg3 = wxString_in_helper(obj2);
40578 if (arg3 == NULL) SWIG_fail;
40579 temp3 = true;
40580 }
40581 {
40582 PyThreadState* __tstate = wxPyBeginAllowThreads();
40583 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 resultobj = SWIG_Py_Void();
40588 {
40589 if (temp3)
40590 delete arg3;
40591 }
40592 return resultobj;
40593 fail:
40594 {
40595 if (temp3)
40596 delete arg3;
40597 }
40598 return NULL;
40599 }
40600
40601
40602 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40603 PyObject *resultobj = 0;
40604 wxMenu *arg1 = (wxMenu *) 0 ;
40605 int arg2 ;
40606 wxString result;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 int val2 ;
40610 int ecode2 = 0 ;
40611 PyObject * obj0 = 0 ;
40612 PyObject * obj1 = 0 ;
40613 char * kwnames[] = {
40614 (char *) "self",(char *) "id", NULL
40615 };
40616
40617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40619 if (!SWIG_IsOK(res1)) {
40620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40621 }
40622 arg1 = reinterpret_cast< wxMenu * >(argp1);
40623 ecode2 = SWIG_AsVal_int(obj1, &val2);
40624 if (!SWIG_IsOK(ecode2)) {
40625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40626 }
40627 arg2 = static_cast< int >(val2);
40628 {
40629 PyThreadState* __tstate = wxPyBeginAllowThreads();
40630 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 {
40635 #if wxUSE_UNICODE
40636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40637 #else
40638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40639 #endif
40640 }
40641 return resultobj;
40642 fail:
40643 return NULL;
40644 }
40645
40646
40647 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40648 PyObject *resultobj = 0;
40649 wxMenu *arg1 = (wxMenu *) 0 ;
40650 int arg2 ;
40651 wxString *arg3 = 0 ;
40652 void *argp1 = 0 ;
40653 int res1 = 0 ;
40654 int val2 ;
40655 int ecode2 = 0 ;
40656 bool temp3 = false ;
40657 PyObject * obj0 = 0 ;
40658 PyObject * obj1 = 0 ;
40659 PyObject * obj2 = 0 ;
40660 char * kwnames[] = {
40661 (char *) "self",(char *) "id",(char *) "helpString", NULL
40662 };
40663
40664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40666 if (!SWIG_IsOK(res1)) {
40667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40668 }
40669 arg1 = reinterpret_cast< wxMenu * >(argp1);
40670 ecode2 = SWIG_AsVal_int(obj1, &val2);
40671 if (!SWIG_IsOK(ecode2)) {
40672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40673 }
40674 arg2 = static_cast< int >(val2);
40675 {
40676 arg3 = wxString_in_helper(obj2);
40677 if (arg3 == NULL) SWIG_fail;
40678 temp3 = true;
40679 }
40680 {
40681 PyThreadState* __tstate = wxPyBeginAllowThreads();
40682 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40683 wxPyEndAllowThreads(__tstate);
40684 if (PyErr_Occurred()) SWIG_fail;
40685 }
40686 resultobj = SWIG_Py_Void();
40687 {
40688 if (temp3)
40689 delete arg3;
40690 }
40691 return resultobj;
40692 fail:
40693 {
40694 if (temp3)
40695 delete arg3;
40696 }
40697 return NULL;
40698 }
40699
40700
40701 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40702 PyObject *resultobj = 0;
40703 wxMenu *arg1 = (wxMenu *) 0 ;
40704 int arg2 ;
40705 wxString result;
40706 void *argp1 = 0 ;
40707 int res1 = 0 ;
40708 int val2 ;
40709 int ecode2 = 0 ;
40710 PyObject * obj0 = 0 ;
40711 PyObject * obj1 = 0 ;
40712 char * kwnames[] = {
40713 (char *) "self",(char *) "id", NULL
40714 };
40715
40716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40718 if (!SWIG_IsOK(res1)) {
40719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40720 }
40721 arg1 = reinterpret_cast< wxMenu * >(argp1);
40722 ecode2 = SWIG_AsVal_int(obj1, &val2);
40723 if (!SWIG_IsOK(ecode2)) {
40724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40725 }
40726 arg2 = static_cast< int >(val2);
40727 {
40728 PyThreadState* __tstate = wxPyBeginAllowThreads();
40729 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40730 wxPyEndAllowThreads(__tstate);
40731 if (PyErr_Occurred()) SWIG_fail;
40732 }
40733 {
40734 #if wxUSE_UNICODE
40735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40736 #else
40737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40738 #endif
40739 }
40740 return resultobj;
40741 fail:
40742 return NULL;
40743 }
40744
40745
40746 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40747 PyObject *resultobj = 0;
40748 wxMenu *arg1 = (wxMenu *) 0 ;
40749 wxString *arg2 = 0 ;
40750 void *argp1 = 0 ;
40751 int res1 = 0 ;
40752 bool temp2 = false ;
40753 PyObject * obj0 = 0 ;
40754 PyObject * obj1 = 0 ;
40755 char * kwnames[] = {
40756 (char *) "self",(char *) "title", NULL
40757 };
40758
40759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40761 if (!SWIG_IsOK(res1)) {
40762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40763 }
40764 arg1 = reinterpret_cast< wxMenu * >(argp1);
40765 {
40766 arg2 = wxString_in_helper(obj1);
40767 if (arg2 == NULL) SWIG_fail;
40768 temp2 = true;
40769 }
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 (arg1)->SetTitle((wxString const &)*arg2);
40773 wxPyEndAllowThreads(__tstate);
40774 if (PyErr_Occurred()) SWIG_fail;
40775 }
40776 resultobj = SWIG_Py_Void();
40777 {
40778 if (temp2)
40779 delete arg2;
40780 }
40781 return resultobj;
40782 fail:
40783 {
40784 if (temp2)
40785 delete arg2;
40786 }
40787 return NULL;
40788 }
40789
40790
40791 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40792 PyObject *resultobj = 0;
40793 wxMenu *arg1 = (wxMenu *) 0 ;
40794 wxString result;
40795 void *argp1 = 0 ;
40796 int res1 = 0 ;
40797 PyObject *swig_obj[1] ;
40798
40799 if (!args) SWIG_fail;
40800 swig_obj[0] = args;
40801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40802 if (!SWIG_IsOK(res1)) {
40803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40804 }
40805 arg1 = reinterpret_cast< wxMenu * >(argp1);
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 result = ((wxMenu const *)arg1)->GetTitle();
40809 wxPyEndAllowThreads(__tstate);
40810 if (PyErr_Occurred()) SWIG_fail;
40811 }
40812 {
40813 #if wxUSE_UNICODE
40814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40815 #else
40816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40817 #endif
40818 }
40819 return resultobj;
40820 fail:
40821 return NULL;
40822 }
40823
40824
40825 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40826 PyObject *resultobj = 0;
40827 wxMenu *arg1 = (wxMenu *) 0 ;
40828 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40829 void *argp1 = 0 ;
40830 int res1 = 0 ;
40831 void *argp2 = 0 ;
40832 int res2 = 0 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char * kwnames[] = {
40836 (char *) "self",(char *) "handler", NULL
40837 };
40838
40839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40841 if (!SWIG_IsOK(res1)) {
40842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40843 }
40844 arg1 = reinterpret_cast< wxMenu * >(argp1);
40845 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40846 if (!SWIG_IsOK(res2)) {
40847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40848 }
40849 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 (arg1)->SetEventHandler(arg2);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 resultobj = SWIG_Py_Void();
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40864 PyObject *resultobj = 0;
40865 wxMenu *arg1 = (wxMenu *) 0 ;
40866 wxEvtHandler *result = 0 ;
40867 void *argp1 = 0 ;
40868 int res1 = 0 ;
40869 PyObject *swig_obj[1] ;
40870
40871 if (!args) SWIG_fail;
40872 swig_obj[0] = args;
40873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40874 if (!SWIG_IsOK(res1)) {
40875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40876 }
40877 arg1 = reinterpret_cast< wxMenu * >(argp1);
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40881 wxPyEndAllowThreads(__tstate);
40882 if (PyErr_Occurred()) SWIG_fail;
40883 }
40884 {
40885 resultobj = wxPyMake_wxObject(result, 0);
40886 }
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40894 PyObject *resultobj = 0;
40895 wxMenu *arg1 = (wxMenu *) 0 ;
40896 wxWindow *arg2 = (wxWindow *) 0 ;
40897 void *argp1 = 0 ;
40898 int res1 = 0 ;
40899 void *argp2 = 0 ;
40900 int res2 = 0 ;
40901 PyObject * obj0 = 0 ;
40902 PyObject * obj1 = 0 ;
40903 char * kwnames[] = {
40904 (char *) "self",(char *) "win", NULL
40905 };
40906
40907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40909 if (!SWIG_IsOK(res1)) {
40910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40911 }
40912 arg1 = reinterpret_cast< wxMenu * >(argp1);
40913 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40914 if (!SWIG_IsOK(res2)) {
40915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40916 }
40917 arg2 = reinterpret_cast< wxWindow * >(argp2);
40918 {
40919 PyThreadState* __tstate = wxPyBeginAllowThreads();
40920 (arg1)->SetInvokingWindow(arg2);
40921 wxPyEndAllowThreads(__tstate);
40922 if (PyErr_Occurred()) SWIG_fail;
40923 }
40924 resultobj = SWIG_Py_Void();
40925 return resultobj;
40926 fail:
40927 return NULL;
40928 }
40929
40930
40931 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40932 PyObject *resultobj = 0;
40933 wxMenu *arg1 = (wxMenu *) 0 ;
40934 wxWindow *result = 0 ;
40935 void *argp1 = 0 ;
40936 int res1 = 0 ;
40937 PyObject *swig_obj[1] ;
40938
40939 if (!args) SWIG_fail;
40940 swig_obj[0] = args;
40941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40942 if (!SWIG_IsOK(res1)) {
40943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40944 }
40945 arg1 = reinterpret_cast< wxMenu * >(argp1);
40946 {
40947 PyThreadState* __tstate = wxPyBeginAllowThreads();
40948 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40949 wxPyEndAllowThreads(__tstate);
40950 if (PyErr_Occurred()) SWIG_fail;
40951 }
40952 {
40953 resultobj = wxPyMake_wxObject(result, 0);
40954 }
40955 return resultobj;
40956 fail:
40957 return NULL;
40958 }
40959
40960
40961 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40962 PyObject *resultobj = 0;
40963 wxMenu *arg1 = (wxMenu *) 0 ;
40964 long result;
40965 void *argp1 = 0 ;
40966 int res1 = 0 ;
40967 PyObject *swig_obj[1] ;
40968
40969 if (!args) SWIG_fail;
40970 swig_obj[0] = args;
40971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40972 if (!SWIG_IsOK(res1)) {
40973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40974 }
40975 arg1 = reinterpret_cast< wxMenu * >(argp1);
40976 {
40977 PyThreadState* __tstate = wxPyBeginAllowThreads();
40978 result = (long)((wxMenu const *)arg1)->GetStyle();
40979 wxPyEndAllowThreads(__tstate);
40980 if (PyErr_Occurred()) SWIG_fail;
40981 }
40982 resultobj = SWIG_From_long(static_cast< long >(result));
40983 return resultobj;
40984 fail:
40985 return NULL;
40986 }
40987
40988
40989 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40990 PyObject *resultobj = 0;
40991 wxMenu *arg1 = (wxMenu *) 0 ;
40992 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40993 void *argp1 = 0 ;
40994 int res1 = 0 ;
40995 void *argp2 = 0 ;
40996 int res2 = 0 ;
40997 PyObject * obj0 = 0 ;
40998 PyObject * obj1 = 0 ;
40999 char * kwnames[] = {
41000 (char *) "self",(char *) "source", NULL
41001 };
41002
41003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41005 if (!SWIG_IsOK(res1)) {
41006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41007 }
41008 arg1 = reinterpret_cast< wxMenu * >(argp1);
41009 if (obj1) {
41010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41011 if (!SWIG_IsOK(res2)) {
41012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41013 }
41014 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41015 }
41016 {
41017 PyThreadState* __tstate = wxPyBeginAllowThreads();
41018 (arg1)->UpdateUI(arg2);
41019 wxPyEndAllowThreads(__tstate);
41020 if (PyErr_Occurred()) SWIG_fail;
41021 }
41022 resultobj = SWIG_Py_Void();
41023 return resultobj;
41024 fail:
41025 return NULL;
41026 }
41027
41028
41029 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41030 PyObject *resultobj = 0;
41031 wxMenu *arg1 = (wxMenu *) 0 ;
41032 wxMenuBar *result = 0 ;
41033 void *argp1 = 0 ;
41034 int res1 = 0 ;
41035 PyObject *swig_obj[1] ;
41036
41037 if (!args) SWIG_fail;
41038 swig_obj[0] = args;
41039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41040 if (!SWIG_IsOK(res1)) {
41041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41042 }
41043 arg1 = reinterpret_cast< wxMenu * >(argp1);
41044 {
41045 PyThreadState* __tstate = wxPyBeginAllowThreads();
41046 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41047 wxPyEndAllowThreads(__tstate);
41048 if (PyErr_Occurred()) SWIG_fail;
41049 }
41050 {
41051 resultobj = wxPyMake_wxObject(result, (bool)0);
41052 }
41053 return resultobj;
41054 fail:
41055 return NULL;
41056 }
41057
41058
41059 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41060 PyObject *resultobj = 0;
41061 wxMenu *arg1 = (wxMenu *) 0 ;
41062 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41063 void *argp1 = 0 ;
41064 int res1 = 0 ;
41065 void *argp2 = 0 ;
41066 int res2 = 0 ;
41067 PyObject * obj0 = 0 ;
41068 PyObject * obj1 = 0 ;
41069 char * kwnames[] = {
41070 (char *) "self",(char *) "menubar", NULL
41071 };
41072
41073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41075 if (!SWIG_IsOK(res1)) {
41076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41077 }
41078 arg1 = reinterpret_cast< wxMenu * >(argp1);
41079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41080 if (!SWIG_IsOK(res2)) {
41081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41082 }
41083 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41084 {
41085 PyThreadState* __tstate = wxPyBeginAllowThreads();
41086 (arg1)->Attach(arg2);
41087 wxPyEndAllowThreads(__tstate);
41088 if (PyErr_Occurred()) SWIG_fail;
41089 }
41090 resultobj = SWIG_Py_Void();
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41098 PyObject *resultobj = 0;
41099 wxMenu *arg1 = (wxMenu *) 0 ;
41100 void *argp1 = 0 ;
41101 int res1 = 0 ;
41102 PyObject *swig_obj[1] ;
41103
41104 if (!args) SWIG_fail;
41105 swig_obj[0] = args;
41106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41107 if (!SWIG_IsOK(res1)) {
41108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41109 }
41110 arg1 = reinterpret_cast< wxMenu * >(argp1);
41111 {
41112 PyThreadState* __tstate = wxPyBeginAllowThreads();
41113 (arg1)->Detach();
41114 wxPyEndAllowThreads(__tstate);
41115 if (PyErr_Occurred()) SWIG_fail;
41116 }
41117 resultobj = SWIG_Py_Void();
41118 return resultobj;
41119 fail:
41120 return NULL;
41121 }
41122
41123
41124 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41125 PyObject *resultobj = 0;
41126 wxMenu *arg1 = (wxMenu *) 0 ;
41127 bool result;
41128 void *argp1 = 0 ;
41129 int res1 = 0 ;
41130 PyObject *swig_obj[1] ;
41131
41132 if (!args) SWIG_fail;
41133 swig_obj[0] = args;
41134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41135 if (!SWIG_IsOK(res1)) {
41136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41137 }
41138 arg1 = reinterpret_cast< wxMenu * >(argp1);
41139 {
41140 PyThreadState* __tstate = wxPyBeginAllowThreads();
41141 result = (bool)((wxMenu const *)arg1)->IsAttached();
41142 wxPyEndAllowThreads(__tstate);
41143 if (PyErr_Occurred()) SWIG_fail;
41144 }
41145 {
41146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41147 }
41148 return resultobj;
41149 fail:
41150 return NULL;
41151 }
41152
41153
41154 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41155 PyObject *resultobj = 0;
41156 wxMenu *arg1 = (wxMenu *) 0 ;
41157 wxMenu *arg2 = (wxMenu *) 0 ;
41158 void *argp1 = 0 ;
41159 int res1 = 0 ;
41160 void *argp2 = 0 ;
41161 int res2 = 0 ;
41162 PyObject * obj0 = 0 ;
41163 PyObject * obj1 = 0 ;
41164 char * kwnames[] = {
41165 (char *) "self",(char *) "parent", NULL
41166 };
41167
41168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41172 }
41173 arg1 = reinterpret_cast< wxMenu * >(argp1);
41174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41175 if (!SWIG_IsOK(res2)) {
41176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41177 }
41178 arg2 = reinterpret_cast< wxMenu * >(argp2);
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 (arg1)->SetParent(arg2);
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 resultobj = SWIG_Py_Void();
41186 return resultobj;
41187 fail:
41188 return NULL;
41189 }
41190
41191
41192 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41193 PyObject *resultobj = 0;
41194 wxMenu *arg1 = (wxMenu *) 0 ;
41195 wxMenu *result = 0 ;
41196 void *argp1 = 0 ;
41197 int res1 = 0 ;
41198 PyObject *swig_obj[1] ;
41199
41200 if (!args) SWIG_fail;
41201 swig_obj[0] = args;
41202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41203 if (!SWIG_IsOK(res1)) {
41204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41205 }
41206 arg1 = reinterpret_cast< wxMenu * >(argp1);
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41210 wxPyEndAllowThreads(__tstate);
41211 if (PyErr_Occurred()) SWIG_fail;
41212 }
41213 {
41214 resultobj = wxPyMake_wxObject(result, 0);
41215 }
41216 return resultobj;
41217 fail:
41218 return NULL;
41219 }
41220
41221
41222 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41223 PyObject *obj;
41224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41225 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41226 return SWIG_Py_Void();
41227 }
41228
41229 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41230 return SWIG_Python_InitShadowInstance(args);
41231 }
41232
41233 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj = 0;
41235 long arg1 = (long) 0 ;
41236 wxMenuBar *result = 0 ;
41237 long val1 ;
41238 int ecode1 = 0 ;
41239 PyObject * obj0 = 0 ;
41240 char * kwnames[] = {
41241 (char *) "style", NULL
41242 };
41243
41244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41245 if (obj0) {
41246 ecode1 = SWIG_AsVal_long(obj0, &val1);
41247 if (!SWIG_IsOK(ecode1)) {
41248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41249 }
41250 arg1 = static_cast< long >(val1);
41251 }
41252 {
41253 if (!wxPyCheckForApp()) SWIG_fail;
41254 PyThreadState* __tstate = wxPyBeginAllowThreads();
41255 result = (wxMenuBar *)new wxMenuBar(arg1);
41256 wxPyEndAllowThreads(__tstate);
41257 if (PyErr_Occurred()) SWIG_fail;
41258 }
41259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41260 return resultobj;
41261 fail:
41262 return NULL;
41263 }
41264
41265
41266 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41267 PyObject *resultobj = 0;
41268 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41269 wxMenu *arg2 = (wxMenu *) 0 ;
41270 wxString *arg3 = 0 ;
41271 bool result;
41272 void *argp1 = 0 ;
41273 int res1 = 0 ;
41274 void *argp2 = 0 ;
41275 int res2 = 0 ;
41276 bool temp3 = false ;
41277 PyObject * obj0 = 0 ;
41278 PyObject * obj1 = 0 ;
41279 PyObject * obj2 = 0 ;
41280 char * kwnames[] = {
41281 (char *) "self",(char *) "menu",(char *) "title", NULL
41282 };
41283
41284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41286 if (!SWIG_IsOK(res1)) {
41287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41288 }
41289 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41290 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41291 if (!SWIG_IsOK(res2)) {
41292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41293 }
41294 arg2 = reinterpret_cast< wxMenu * >(argp2);
41295 {
41296 arg3 = wxString_in_helper(obj2);
41297 if (arg3 == NULL) SWIG_fail;
41298 temp3 = true;
41299 }
41300 {
41301 PyThreadState* __tstate = wxPyBeginAllowThreads();
41302 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41303 wxPyEndAllowThreads(__tstate);
41304 if (PyErr_Occurred()) SWIG_fail;
41305 }
41306 {
41307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41308 }
41309 {
41310 if (temp3)
41311 delete arg3;
41312 }
41313 return resultobj;
41314 fail:
41315 {
41316 if (temp3)
41317 delete arg3;
41318 }
41319 return NULL;
41320 }
41321
41322
41323 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41324 PyObject *resultobj = 0;
41325 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41326 size_t arg2 ;
41327 wxMenu *arg3 = (wxMenu *) 0 ;
41328 wxString *arg4 = 0 ;
41329 bool result;
41330 void *argp1 = 0 ;
41331 int res1 = 0 ;
41332 size_t val2 ;
41333 int ecode2 = 0 ;
41334 void *argp3 = 0 ;
41335 int res3 = 0 ;
41336 bool temp4 = false ;
41337 PyObject * obj0 = 0 ;
41338 PyObject * obj1 = 0 ;
41339 PyObject * obj2 = 0 ;
41340 PyObject * obj3 = 0 ;
41341 char * kwnames[] = {
41342 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41343 };
41344
41345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41347 if (!SWIG_IsOK(res1)) {
41348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41349 }
41350 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41351 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41352 if (!SWIG_IsOK(ecode2)) {
41353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41354 }
41355 arg2 = static_cast< size_t >(val2);
41356 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41357 if (!SWIG_IsOK(res3)) {
41358 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41359 }
41360 arg3 = reinterpret_cast< wxMenu * >(argp3);
41361 {
41362 arg4 = wxString_in_helper(obj3);
41363 if (arg4 == NULL) SWIG_fail;
41364 temp4 = true;
41365 }
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41369 wxPyEndAllowThreads(__tstate);
41370 if (PyErr_Occurred()) SWIG_fail;
41371 }
41372 {
41373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41374 }
41375 {
41376 if (temp4)
41377 delete arg4;
41378 }
41379 return resultobj;
41380 fail:
41381 {
41382 if (temp4)
41383 delete arg4;
41384 }
41385 return NULL;
41386 }
41387
41388
41389 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41390 PyObject *resultobj = 0;
41391 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41392 size_t result;
41393 void *argp1 = 0 ;
41394 int res1 = 0 ;
41395 PyObject *swig_obj[1] ;
41396
41397 if (!args) SWIG_fail;
41398 swig_obj[0] = args;
41399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41400 if (!SWIG_IsOK(res1)) {
41401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41402 }
41403 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41404 {
41405 PyThreadState* __tstate = wxPyBeginAllowThreads();
41406 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41407 wxPyEndAllowThreads(__tstate);
41408 if (PyErr_Occurred()) SWIG_fail;
41409 }
41410 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41411 return resultobj;
41412 fail:
41413 return NULL;
41414 }
41415
41416
41417 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41418 PyObject *resultobj = 0;
41419 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41420 size_t arg2 ;
41421 wxMenu *result = 0 ;
41422 void *argp1 = 0 ;
41423 int res1 = 0 ;
41424 size_t val2 ;
41425 int ecode2 = 0 ;
41426 PyObject * obj0 = 0 ;
41427 PyObject * obj1 = 0 ;
41428 char * kwnames[] = {
41429 (char *) "self",(char *) "pos", NULL
41430 };
41431
41432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41434 if (!SWIG_IsOK(res1)) {
41435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41436 }
41437 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41438 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41439 if (!SWIG_IsOK(ecode2)) {
41440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41441 }
41442 arg2 = static_cast< size_t >(val2);
41443 {
41444 PyThreadState* __tstate = wxPyBeginAllowThreads();
41445 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41446 wxPyEndAllowThreads(__tstate);
41447 if (PyErr_Occurred()) SWIG_fail;
41448 }
41449 {
41450 resultobj = wxPyMake_wxObject(result, 0);
41451 }
41452 return resultobj;
41453 fail:
41454 return NULL;
41455 }
41456
41457
41458 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41459 PyObject *resultobj = 0;
41460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41461 size_t arg2 ;
41462 wxMenu *arg3 = (wxMenu *) 0 ;
41463 wxString *arg4 = 0 ;
41464 wxMenu *result = 0 ;
41465 void *argp1 = 0 ;
41466 int res1 = 0 ;
41467 size_t val2 ;
41468 int ecode2 = 0 ;
41469 void *argp3 = 0 ;
41470 int res3 = 0 ;
41471 bool temp4 = false ;
41472 PyObject * obj0 = 0 ;
41473 PyObject * obj1 = 0 ;
41474 PyObject * obj2 = 0 ;
41475 PyObject * obj3 = 0 ;
41476 char * kwnames[] = {
41477 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41478 };
41479
41480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41482 if (!SWIG_IsOK(res1)) {
41483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41484 }
41485 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41486 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41487 if (!SWIG_IsOK(ecode2)) {
41488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41489 }
41490 arg2 = static_cast< size_t >(val2);
41491 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41492 if (!SWIG_IsOK(res3)) {
41493 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41494 }
41495 arg3 = reinterpret_cast< wxMenu * >(argp3);
41496 {
41497 arg4 = wxString_in_helper(obj3);
41498 if (arg4 == NULL) SWIG_fail;
41499 temp4 = true;
41500 }
41501 {
41502 PyThreadState* __tstate = wxPyBeginAllowThreads();
41503 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41504 wxPyEndAllowThreads(__tstate);
41505 if (PyErr_Occurred()) SWIG_fail;
41506 }
41507 {
41508 resultobj = wxPyMake_wxObject(result, 0);
41509 }
41510 {
41511 if (temp4)
41512 delete arg4;
41513 }
41514 return resultobj;
41515 fail:
41516 {
41517 if (temp4)
41518 delete arg4;
41519 }
41520 return NULL;
41521 }
41522
41523
41524 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41525 PyObject *resultobj = 0;
41526 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41527 size_t arg2 ;
41528 wxMenu *result = 0 ;
41529 void *argp1 = 0 ;
41530 int res1 = 0 ;
41531 size_t val2 ;
41532 int ecode2 = 0 ;
41533 PyObject * obj0 = 0 ;
41534 PyObject * obj1 = 0 ;
41535 char * kwnames[] = {
41536 (char *) "self",(char *) "pos", NULL
41537 };
41538
41539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41541 if (!SWIG_IsOK(res1)) {
41542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41543 }
41544 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41545 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41546 if (!SWIG_IsOK(ecode2)) {
41547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41548 }
41549 arg2 = static_cast< size_t >(val2);
41550 {
41551 PyThreadState* __tstate = wxPyBeginAllowThreads();
41552 result = (wxMenu *)(arg1)->Remove(arg2);
41553 wxPyEndAllowThreads(__tstate);
41554 if (PyErr_Occurred()) SWIG_fail;
41555 }
41556 {
41557 resultobj = wxPyMake_wxObject(result, 0);
41558 }
41559 return resultobj;
41560 fail:
41561 return NULL;
41562 }
41563
41564
41565 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41566 PyObject *resultobj = 0;
41567 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41568 size_t arg2 ;
41569 bool arg3 ;
41570 void *argp1 = 0 ;
41571 int res1 = 0 ;
41572 size_t val2 ;
41573 int ecode2 = 0 ;
41574 bool val3 ;
41575 int ecode3 = 0 ;
41576 PyObject * obj0 = 0 ;
41577 PyObject * obj1 = 0 ;
41578 PyObject * obj2 = 0 ;
41579 char * kwnames[] = {
41580 (char *) "self",(char *) "pos",(char *) "enable", NULL
41581 };
41582
41583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41585 if (!SWIG_IsOK(res1)) {
41586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41587 }
41588 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41589 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41590 if (!SWIG_IsOK(ecode2)) {
41591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41592 }
41593 arg2 = static_cast< size_t >(val2);
41594 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41595 if (!SWIG_IsOK(ecode3)) {
41596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41597 }
41598 arg3 = static_cast< bool >(val3);
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 (arg1)->EnableTop(arg2,arg3);
41602 wxPyEndAllowThreads(__tstate);
41603 if (PyErr_Occurred()) SWIG_fail;
41604 }
41605 resultobj = SWIG_Py_Void();
41606 return resultobj;
41607 fail:
41608 return NULL;
41609 }
41610
41611
41612 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41613 PyObject *resultobj = 0;
41614 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41615 size_t arg2 ;
41616 bool result;
41617 void *argp1 = 0 ;
41618 int res1 = 0 ;
41619 size_t val2 ;
41620 int ecode2 = 0 ;
41621 PyObject * obj0 = 0 ;
41622 PyObject * obj1 = 0 ;
41623 char * kwnames[] = {
41624 (char *) "self",(char *) "pos", NULL
41625 };
41626
41627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41629 if (!SWIG_IsOK(res1)) {
41630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41631 }
41632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41633 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41634 if (!SWIG_IsOK(ecode2)) {
41635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41636 }
41637 arg2 = static_cast< size_t >(val2);
41638 {
41639 PyThreadState* __tstate = wxPyBeginAllowThreads();
41640 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41641 wxPyEndAllowThreads(__tstate);
41642 if (PyErr_Occurred()) SWIG_fail;
41643 }
41644 {
41645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41646 }
41647 return resultobj;
41648 fail:
41649 return NULL;
41650 }
41651
41652
41653 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41654 PyObject *resultobj = 0;
41655 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41656 size_t arg2 ;
41657 wxString *arg3 = 0 ;
41658 void *argp1 = 0 ;
41659 int res1 = 0 ;
41660 size_t val2 ;
41661 int ecode2 = 0 ;
41662 bool temp3 = false ;
41663 PyObject * obj0 = 0 ;
41664 PyObject * obj1 = 0 ;
41665 PyObject * obj2 = 0 ;
41666 char * kwnames[] = {
41667 (char *) "self",(char *) "pos",(char *) "label", NULL
41668 };
41669
41670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41672 if (!SWIG_IsOK(res1)) {
41673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41674 }
41675 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41676 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41677 if (!SWIG_IsOK(ecode2)) {
41678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41679 }
41680 arg2 = static_cast< size_t >(val2);
41681 {
41682 arg3 = wxString_in_helper(obj2);
41683 if (arg3 == NULL) SWIG_fail;
41684 temp3 = true;
41685 }
41686 {
41687 PyThreadState* __tstate = wxPyBeginAllowThreads();
41688 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41689 wxPyEndAllowThreads(__tstate);
41690 if (PyErr_Occurred()) SWIG_fail;
41691 }
41692 resultobj = SWIG_Py_Void();
41693 {
41694 if (temp3)
41695 delete arg3;
41696 }
41697 return resultobj;
41698 fail:
41699 {
41700 if (temp3)
41701 delete arg3;
41702 }
41703 return NULL;
41704 }
41705
41706
41707 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41708 PyObject *resultobj = 0;
41709 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41710 size_t arg2 ;
41711 wxString result;
41712 void *argp1 = 0 ;
41713 int res1 = 0 ;
41714 size_t val2 ;
41715 int ecode2 = 0 ;
41716 PyObject * obj0 = 0 ;
41717 PyObject * obj1 = 0 ;
41718 char * kwnames[] = {
41719 (char *) "self",(char *) "pos", NULL
41720 };
41721
41722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41724 if (!SWIG_IsOK(res1)) {
41725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41726 }
41727 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41728 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41729 if (!SWIG_IsOK(ecode2)) {
41730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41731 }
41732 arg2 = static_cast< size_t >(val2);
41733 {
41734 PyThreadState* __tstate = wxPyBeginAllowThreads();
41735 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41736 wxPyEndAllowThreads(__tstate);
41737 if (PyErr_Occurred()) SWIG_fail;
41738 }
41739 {
41740 #if wxUSE_UNICODE
41741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41742 #else
41743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41744 #endif
41745 }
41746 return resultobj;
41747 fail:
41748 return NULL;
41749 }
41750
41751
41752 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj = 0;
41754 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41755 wxString *arg2 = 0 ;
41756 wxString *arg3 = 0 ;
41757 int result;
41758 void *argp1 = 0 ;
41759 int res1 = 0 ;
41760 bool temp2 = false ;
41761 bool temp3 = false ;
41762 PyObject * obj0 = 0 ;
41763 PyObject * obj1 = 0 ;
41764 PyObject * obj2 = 0 ;
41765 char * kwnames[] = {
41766 (char *) "self",(char *) "menu",(char *) "item", NULL
41767 };
41768
41769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41771 if (!SWIG_IsOK(res1)) {
41772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41773 }
41774 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41775 {
41776 arg2 = wxString_in_helper(obj1);
41777 if (arg2 == NULL) SWIG_fail;
41778 temp2 = true;
41779 }
41780 {
41781 arg3 = wxString_in_helper(obj2);
41782 if (arg3 == NULL) SWIG_fail;
41783 temp3 = true;
41784 }
41785 {
41786 PyThreadState* __tstate = wxPyBeginAllowThreads();
41787 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41788 wxPyEndAllowThreads(__tstate);
41789 if (PyErr_Occurred()) SWIG_fail;
41790 }
41791 resultobj = SWIG_From_int(static_cast< int >(result));
41792 {
41793 if (temp2)
41794 delete arg2;
41795 }
41796 {
41797 if (temp3)
41798 delete arg3;
41799 }
41800 return resultobj;
41801 fail:
41802 {
41803 if (temp2)
41804 delete arg2;
41805 }
41806 {
41807 if (temp3)
41808 delete arg3;
41809 }
41810 return NULL;
41811 }
41812
41813
41814 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj = 0;
41816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41817 int arg2 ;
41818 wxMenuItem *result = 0 ;
41819 void *argp1 = 0 ;
41820 int res1 = 0 ;
41821 int val2 ;
41822 int ecode2 = 0 ;
41823 PyObject * obj0 = 0 ;
41824 PyObject * obj1 = 0 ;
41825 char * kwnames[] = {
41826 (char *) "self",(char *) "id", NULL
41827 };
41828
41829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41831 if (!SWIG_IsOK(res1)) {
41832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41833 }
41834 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41835 ecode2 = SWIG_AsVal_int(obj1, &val2);
41836 if (!SWIG_IsOK(ecode2)) {
41837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41838 }
41839 arg2 = static_cast< int >(val2);
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 {
41847 resultobj = wxPyMake_wxObject(result, (bool)0);
41848 }
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj = 0;
41857 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41858 wxString *arg2 = 0 ;
41859 int result;
41860 void *argp1 = 0 ;
41861 int res1 = 0 ;
41862 bool temp2 = false ;
41863 PyObject * obj0 = 0 ;
41864 PyObject * obj1 = 0 ;
41865 char * kwnames[] = {
41866 (char *) "self",(char *) "title", NULL
41867 };
41868
41869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41871 if (!SWIG_IsOK(res1)) {
41872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41873 }
41874 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41875 {
41876 arg2 = wxString_in_helper(obj1);
41877 if (arg2 == NULL) SWIG_fail;
41878 temp2 = true;
41879 }
41880 {
41881 PyThreadState* __tstate = wxPyBeginAllowThreads();
41882 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41883 wxPyEndAllowThreads(__tstate);
41884 if (PyErr_Occurred()) SWIG_fail;
41885 }
41886 resultobj = SWIG_From_int(static_cast< int >(result));
41887 {
41888 if (temp2)
41889 delete arg2;
41890 }
41891 return resultobj;
41892 fail:
41893 {
41894 if (temp2)
41895 delete arg2;
41896 }
41897 return NULL;
41898 }
41899
41900
41901 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41902 PyObject *resultobj = 0;
41903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41904 int arg2 ;
41905 bool arg3 ;
41906 void *argp1 = 0 ;
41907 int res1 = 0 ;
41908 int val2 ;
41909 int ecode2 = 0 ;
41910 bool val3 ;
41911 int ecode3 = 0 ;
41912 PyObject * obj0 = 0 ;
41913 PyObject * obj1 = 0 ;
41914 PyObject * obj2 = 0 ;
41915 char * kwnames[] = {
41916 (char *) "self",(char *) "id",(char *) "enable", NULL
41917 };
41918
41919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41921 if (!SWIG_IsOK(res1)) {
41922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41923 }
41924 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41925 ecode2 = SWIG_AsVal_int(obj1, &val2);
41926 if (!SWIG_IsOK(ecode2)) {
41927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41928 }
41929 arg2 = static_cast< int >(val2);
41930 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41931 if (!SWIG_IsOK(ecode3)) {
41932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41933 }
41934 arg3 = static_cast< bool >(val3);
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 (arg1)->Enable(arg2,arg3);
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 resultobj = SWIG_Py_Void();
41942 return resultobj;
41943 fail:
41944 return NULL;
41945 }
41946
41947
41948 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41949 PyObject *resultobj = 0;
41950 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41951 int arg2 ;
41952 bool arg3 ;
41953 void *argp1 = 0 ;
41954 int res1 = 0 ;
41955 int val2 ;
41956 int ecode2 = 0 ;
41957 bool val3 ;
41958 int ecode3 = 0 ;
41959 PyObject * obj0 = 0 ;
41960 PyObject * obj1 = 0 ;
41961 PyObject * obj2 = 0 ;
41962 char * kwnames[] = {
41963 (char *) "self",(char *) "id",(char *) "check", NULL
41964 };
41965
41966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41968 if (!SWIG_IsOK(res1)) {
41969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41970 }
41971 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41972 ecode2 = SWIG_AsVal_int(obj1, &val2);
41973 if (!SWIG_IsOK(ecode2)) {
41974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41975 }
41976 arg2 = static_cast< int >(val2);
41977 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41978 if (!SWIG_IsOK(ecode3)) {
41979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41980 }
41981 arg3 = static_cast< bool >(val3);
41982 {
41983 PyThreadState* __tstate = wxPyBeginAllowThreads();
41984 (arg1)->Check(arg2,arg3);
41985 wxPyEndAllowThreads(__tstate);
41986 if (PyErr_Occurred()) SWIG_fail;
41987 }
41988 resultobj = SWIG_Py_Void();
41989 return resultobj;
41990 fail:
41991 return NULL;
41992 }
41993
41994
41995 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41996 PyObject *resultobj = 0;
41997 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41998 int arg2 ;
41999 bool result;
42000 void *argp1 = 0 ;
42001 int res1 = 0 ;
42002 int val2 ;
42003 int ecode2 = 0 ;
42004 PyObject * obj0 = 0 ;
42005 PyObject * obj1 = 0 ;
42006 char * kwnames[] = {
42007 (char *) "self",(char *) "id", NULL
42008 };
42009
42010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42012 if (!SWIG_IsOK(res1)) {
42013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42014 }
42015 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42016 ecode2 = SWIG_AsVal_int(obj1, &val2);
42017 if (!SWIG_IsOK(ecode2)) {
42018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42019 }
42020 arg2 = static_cast< int >(val2);
42021 {
42022 PyThreadState* __tstate = wxPyBeginAllowThreads();
42023 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42024 wxPyEndAllowThreads(__tstate);
42025 if (PyErr_Occurred()) SWIG_fail;
42026 }
42027 {
42028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42029 }
42030 return resultobj;
42031 fail:
42032 return NULL;
42033 }
42034
42035
42036 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42037 PyObject *resultobj = 0;
42038 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42039 int arg2 ;
42040 bool result;
42041 void *argp1 = 0 ;
42042 int res1 = 0 ;
42043 int val2 ;
42044 int ecode2 = 0 ;
42045 PyObject * obj0 = 0 ;
42046 PyObject * obj1 = 0 ;
42047 char * kwnames[] = {
42048 (char *) "self",(char *) "id", NULL
42049 };
42050
42051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42053 if (!SWIG_IsOK(res1)) {
42054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42055 }
42056 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42057 ecode2 = SWIG_AsVal_int(obj1, &val2);
42058 if (!SWIG_IsOK(ecode2)) {
42059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42060 }
42061 arg2 = static_cast< int >(val2);
42062 {
42063 PyThreadState* __tstate = wxPyBeginAllowThreads();
42064 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42065 wxPyEndAllowThreads(__tstate);
42066 if (PyErr_Occurred()) SWIG_fail;
42067 }
42068 {
42069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42070 }
42071 return resultobj;
42072 fail:
42073 return NULL;
42074 }
42075
42076
42077 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42078 PyObject *resultobj = 0;
42079 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42080 int arg2 ;
42081 wxString *arg3 = 0 ;
42082 void *argp1 = 0 ;
42083 int res1 = 0 ;
42084 int val2 ;
42085 int ecode2 = 0 ;
42086 bool temp3 = false ;
42087 PyObject * obj0 = 0 ;
42088 PyObject * obj1 = 0 ;
42089 PyObject * obj2 = 0 ;
42090 char * kwnames[] = {
42091 (char *) "self",(char *) "id",(char *) "label", NULL
42092 };
42093
42094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42096 if (!SWIG_IsOK(res1)) {
42097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42098 }
42099 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42100 ecode2 = SWIG_AsVal_int(obj1, &val2);
42101 if (!SWIG_IsOK(ecode2)) {
42102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42103 }
42104 arg2 = static_cast< int >(val2);
42105 {
42106 arg3 = wxString_in_helper(obj2);
42107 if (arg3 == NULL) SWIG_fail;
42108 temp3 = true;
42109 }
42110 {
42111 PyThreadState* __tstate = wxPyBeginAllowThreads();
42112 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42113 wxPyEndAllowThreads(__tstate);
42114 if (PyErr_Occurred()) SWIG_fail;
42115 }
42116 resultobj = SWIG_Py_Void();
42117 {
42118 if (temp3)
42119 delete arg3;
42120 }
42121 return resultobj;
42122 fail:
42123 {
42124 if (temp3)
42125 delete arg3;
42126 }
42127 return NULL;
42128 }
42129
42130
42131 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj = 0;
42133 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42134 int arg2 ;
42135 wxString result;
42136 void *argp1 = 0 ;
42137 int res1 = 0 ;
42138 int val2 ;
42139 int ecode2 = 0 ;
42140 PyObject * obj0 = 0 ;
42141 PyObject * obj1 = 0 ;
42142 char * kwnames[] = {
42143 (char *) "self",(char *) "id", NULL
42144 };
42145
42146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42148 if (!SWIG_IsOK(res1)) {
42149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42150 }
42151 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42152 ecode2 = SWIG_AsVal_int(obj1, &val2);
42153 if (!SWIG_IsOK(ecode2)) {
42154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42155 }
42156 arg2 = static_cast< int >(val2);
42157 {
42158 PyThreadState* __tstate = wxPyBeginAllowThreads();
42159 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42160 wxPyEndAllowThreads(__tstate);
42161 if (PyErr_Occurred()) SWIG_fail;
42162 }
42163 {
42164 #if wxUSE_UNICODE
42165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42166 #else
42167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42168 #endif
42169 }
42170 return resultobj;
42171 fail:
42172 return NULL;
42173 }
42174
42175
42176 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42177 PyObject *resultobj = 0;
42178 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42179 int arg2 ;
42180 wxString *arg3 = 0 ;
42181 void *argp1 = 0 ;
42182 int res1 = 0 ;
42183 int val2 ;
42184 int ecode2 = 0 ;
42185 bool temp3 = false ;
42186 PyObject * obj0 = 0 ;
42187 PyObject * obj1 = 0 ;
42188 PyObject * obj2 = 0 ;
42189 char * kwnames[] = {
42190 (char *) "self",(char *) "id",(char *) "helpString", NULL
42191 };
42192
42193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42195 if (!SWIG_IsOK(res1)) {
42196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42197 }
42198 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42199 ecode2 = SWIG_AsVal_int(obj1, &val2);
42200 if (!SWIG_IsOK(ecode2)) {
42201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42202 }
42203 arg2 = static_cast< int >(val2);
42204 {
42205 arg3 = wxString_in_helper(obj2);
42206 if (arg3 == NULL) SWIG_fail;
42207 temp3 = true;
42208 }
42209 {
42210 PyThreadState* __tstate = wxPyBeginAllowThreads();
42211 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42212 wxPyEndAllowThreads(__tstate);
42213 if (PyErr_Occurred()) SWIG_fail;
42214 }
42215 resultobj = SWIG_Py_Void();
42216 {
42217 if (temp3)
42218 delete arg3;
42219 }
42220 return resultobj;
42221 fail:
42222 {
42223 if (temp3)
42224 delete arg3;
42225 }
42226 return NULL;
42227 }
42228
42229
42230 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42231 PyObject *resultobj = 0;
42232 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42233 int arg2 ;
42234 wxString result;
42235 void *argp1 = 0 ;
42236 int res1 = 0 ;
42237 int val2 ;
42238 int ecode2 = 0 ;
42239 PyObject * obj0 = 0 ;
42240 PyObject * obj1 = 0 ;
42241 char * kwnames[] = {
42242 (char *) "self",(char *) "id", NULL
42243 };
42244
42245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42247 if (!SWIG_IsOK(res1)) {
42248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42249 }
42250 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42251 ecode2 = SWIG_AsVal_int(obj1, &val2);
42252 if (!SWIG_IsOK(ecode2)) {
42253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42254 }
42255 arg2 = static_cast< int >(val2);
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42259 wxPyEndAllowThreads(__tstate);
42260 if (PyErr_Occurred()) SWIG_fail;
42261 }
42262 {
42263 #if wxUSE_UNICODE
42264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42265 #else
42266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42267 #endif
42268 }
42269 return resultobj;
42270 fail:
42271 return NULL;
42272 }
42273
42274
42275 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42276 PyObject *resultobj = 0;
42277 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42278 wxFrame *result = 0 ;
42279 void *argp1 = 0 ;
42280 int res1 = 0 ;
42281 PyObject *swig_obj[1] ;
42282
42283 if (!args) SWIG_fail;
42284 swig_obj[0] = args;
42285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42286 if (!SWIG_IsOK(res1)) {
42287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42288 }
42289 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42290 {
42291 PyThreadState* __tstate = wxPyBeginAllowThreads();
42292 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42293 wxPyEndAllowThreads(__tstate);
42294 if (PyErr_Occurred()) SWIG_fail;
42295 }
42296 {
42297 resultobj = wxPyMake_wxObject(result, (bool)0);
42298 }
42299 return resultobj;
42300 fail:
42301 return NULL;
42302 }
42303
42304
42305 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42306 PyObject *resultobj = 0;
42307 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42308 bool result;
42309 void *argp1 = 0 ;
42310 int res1 = 0 ;
42311 PyObject *swig_obj[1] ;
42312
42313 if (!args) SWIG_fail;
42314 swig_obj[0] = args;
42315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42316 if (!SWIG_IsOK(res1)) {
42317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42318 }
42319 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42323 wxPyEndAllowThreads(__tstate);
42324 if (PyErr_Occurred()) SWIG_fail;
42325 }
42326 {
42327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42328 }
42329 return resultobj;
42330 fail:
42331 return NULL;
42332 }
42333
42334
42335 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42336 PyObject *resultobj = 0;
42337 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42338 wxFrame *arg2 = (wxFrame *) 0 ;
42339 void *argp1 = 0 ;
42340 int res1 = 0 ;
42341 void *argp2 = 0 ;
42342 int res2 = 0 ;
42343 PyObject * obj0 = 0 ;
42344 PyObject * obj1 = 0 ;
42345 char * kwnames[] = {
42346 (char *) "self",(char *) "frame", NULL
42347 };
42348
42349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42351 if (!SWIG_IsOK(res1)) {
42352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42353 }
42354 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42355 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42356 if (!SWIG_IsOK(res2)) {
42357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42358 }
42359 arg2 = reinterpret_cast< wxFrame * >(argp2);
42360 {
42361 PyThreadState* __tstate = wxPyBeginAllowThreads();
42362 (arg1)->Attach(arg2);
42363 wxPyEndAllowThreads(__tstate);
42364 if (PyErr_Occurred()) SWIG_fail;
42365 }
42366 resultobj = SWIG_Py_Void();
42367 return resultobj;
42368 fail:
42369 return NULL;
42370 }
42371
42372
42373 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42374 PyObject *resultobj = 0;
42375 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42376 void *argp1 = 0 ;
42377 int res1 = 0 ;
42378 PyObject *swig_obj[1] ;
42379
42380 if (!args) SWIG_fail;
42381 swig_obj[0] = args;
42382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42383 if (!SWIG_IsOK(res1)) {
42384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42385 }
42386 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42387 {
42388 PyThreadState* __tstate = wxPyBeginAllowThreads();
42389 (arg1)->Detach();
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 resultobj = SWIG_Py_Void();
42394 return resultobj;
42395 fail:
42396 return NULL;
42397 }
42398
42399
42400 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42401 PyObject *resultobj = 0;
42402 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42403 void *argp1 = 0 ;
42404 int res1 = 0 ;
42405 PyObject *swig_obj[1] ;
42406
42407 if (!args) SWIG_fail;
42408 swig_obj[0] = args;
42409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42410 if (!SWIG_IsOK(res1)) {
42411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42412 }
42413 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42414 {
42415 PyThreadState* __tstate = wxPyBeginAllowThreads();
42416 (arg1)->UpdateMenus();
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_Py_Void();
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj = 0;
42429 bool arg1 ;
42430 bool val1 ;
42431 int ecode1 = 0 ;
42432 PyObject * obj0 = 0 ;
42433 char * kwnames[] = {
42434 (char *) "enable", NULL
42435 };
42436
42437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42438 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42439 if (!SWIG_IsOK(ecode1)) {
42440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42441 }
42442 arg1 = static_cast< bool >(val1);
42443 {
42444 PyThreadState* __tstate = wxPyBeginAllowThreads();
42445 wxMenuBar_SetAutoWindowMenu(arg1);
42446 wxPyEndAllowThreads(__tstate);
42447 if (PyErr_Occurred()) SWIG_fail;
42448 }
42449 resultobj = SWIG_Py_Void();
42450 return resultobj;
42451 fail:
42452 return NULL;
42453 }
42454
42455
42456 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42457 PyObject *resultobj = 0;
42458 bool result;
42459
42460 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42461 {
42462 PyThreadState* __tstate = wxPyBeginAllowThreads();
42463 result = (bool)wxMenuBar_GetAutoWindowMenu();
42464 wxPyEndAllowThreads(__tstate);
42465 if (PyErr_Occurred()) SWIG_fail;
42466 }
42467 {
42468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42469 }
42470 return resultobj;
42471 fail:
42472 return NULL;
42473 }
42474
42475
42476 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42477 PyObject *obj;
42478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42479 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42480 return SWIG_Py_Void();
42481 }
42482
42483 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42484 return SWIG_Python_InitShadowInstance(args);
42485 }
42486
42487 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42488 PyObject *resultobj = 0;
42489 wxMenu *arg1 = (wxMenu *) NULL ;
42490 int arg2 = (int) wxID_ANY ;
42491 wxString const &arg3_defvalue = wxPyEmptyString ;
42492 wxString *arg3 = (wxString *) &arg3_defvalue ;
42493 wxString const &arg4_defvalue = wxPyEmptyString ;
42494 wxString *arg4 = (wxString *) &arg4_defvalue ;
42495 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42496 wxMenu *arg6 = (wxMenu *) NULL ;
42497 wxMenuItem *result = 0 ;
42498 void *argp1 = 0 ;
42499 int res1 = 0 ;
42500 int val2 ;
42501 int ecode2 = 0 ;
42502 bool temp3 = false ;
42503 bool temp4 = false ;
42504 int val5 ;
42505 int ecode5 = 0 ;
42506 void *argp6 = 0 ;
42507 int res6 = 0 ;
42508 PyObject * obj0 = 0 ;
42509 PyObject * obj1 = 0 ;
42510 PyObject * obj2 = 0 ;
42511 PyObject * obj3 = 0 ;
42512 PyObject * obj4 = 0 ;
42513 PyObject * obj5 = 0 ;
42514 char * kwnames[] = {
42515 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42516 };
42517
42518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42519 if (obj0) {
42520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42521 if (!SWIG_IsOK(res1)) {
42522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42523 }
42524 arg1 = reinterpret_cast< wxMenu * >(argp1);
42525 }
42526 if (obj1) {
42527 ecode2 = SWIG_AsVal_int(obj1, &val2);
42528 if (!SWIG_IsOK(ecode2)) {
42529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42530 }
42531 arg2 = static_cast< int >(val2);
42532 }
42533 if (obj2) {
42534 {
42535 arg3 = wxString_in_helper(obj2);
42536 if (arg3 == NULL) SWIG_fail;
42537 temp3 = true;
42538 }
42539 }
42540 if (obj3) {
42541 {
42542 arg4 = wxString_in_helper(obj3);
42543 if (arg4 == NULL) SWIG_fail;
42544 temp4 = true;
42545 }
42546 }
42547 if (obj4) {
42548 ecode5 = SWIG_AsVal_int(obj4, &val5);
42549 if (!SWIG_IsOK(ecode5)) {
42550 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42551 }
42552 arg5 = static_cast< wxItemKind >(val5);
42553 }
42554 if (obj5) {
42555 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42556 if (!SWIG_IsOK(res6)) {
42557 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42558 }
42559 arg6 = reinterpret_cast< wxMenu * >(argp6);
42560 }
42561 {
42562 PyThreadState* __tstate = wxPyBeginAllowThreads();
42563 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42564 wxPyEndAllowThreads(__tstate);
42565 if (PyErr_Occurred()) SWIG_fail;
42566 }
42567 {
42568 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42569 }
42570 {
42571 if (temp3)
42572 delete arg3;
42573 }
42574 {
42575 if (temp4)
42576 delete arg4;
42577 }
42578 return resultobj;
42579 fail:
42580 {
42581 if (temp3)
42582 delete arg3;
42583 }
42584 {
42585 if (temp4)
42586 delete arg4;
42587 }
42588 return NULL;
42589 }
42590
42591
42592 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42593 PyObject *resultobj = 0;
42594 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42595 void *argp1 = 0 ;
42596 int res1 = 0 ;
42597 PyObject *swig_obj[1] ;
42598
42599 if (!args) SWIG_fail;
42600 swig_obj[0] = args;
42601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42602 if (!SWIG_IsOK(res1)) {
42603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42604 }
42605 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42606 {
42607 PyThreadState* __tstate = wxPyBeginAllowThreads();
42608 delete arg1;
42609
42610 wxPyEndAllowThreads(__tstate);
42611 if (PyErr_Occurred()) SWIG_fail;
42612 }
42613 resultobj = SWIG_Py_Void();
42614 return resultobj;
42615 fail:
42616 return NULL;
42617 }
42618
42619
42620 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42621 PyObject *resultobj = 0;
42622 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42623 wxMenu *result = 0 ;
42624 void *argp1 = 0 ;
42625 int res1 = 0 ;
42626 PyObject *swig_obj[1] ;
42627
42628 if (!args) SWIG_fail;
42629 swig_obj[0] = args;
42630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42631 if (!SWIG_IsOK(res1)) {
42632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42633 }
42634 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42635 {
42636 PyThreadState* __tstate = wxPyBeginAllowThreads();
42637 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42638 wxPyEndAllowThreads(__tstate);
42639 if (PyErr_Occurred()) SWIG_fail;
42640 }
42641 {
42642 resultobj = wxPyMake_wxObject(result, 0);
42643 }
42644 return resultobj;
42645 fail:
42646 return NULL;
42647 }
42648
42649
42650 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42651 PyObject *resultobj = 0;
42652 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42653 wxMenu *arg2 = (wxMenu *) 0 ;
42654 void *argp1 = 0 ;
42655 int res1 = 0 ;
42656 void *argp2 = 0 ;
42657 int res2 = 0 ;
42658 PyObject * obj0 = 0 ;
42659 PyObject * obj1 = 0 ;
42660 char * kwnames[] = {
42661 (char *) "self",(char *) "menu", NULL
42662 };
42663
42664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42666 if (!SWIG_IsOK(res1)) {
42667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42668 }
42669 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42671 if (!SWIG_IsOK(res2)) {
42672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42673 }
42674 arg2 = reinterpret_cast< wxMenu * >(argp2);
42675 {
42676 PyThreadState* __tstate = wxPyBeginAllowThreads();
42677 (arg1)->SetMenu(arg2);
42678 wxPyEndAllowThreads(__tstate);
42679 if (PyErr_Occurred()) SWIG_fail;
42680 }
42681 resultobj = SWIG_Py_Void();
42682 return resultobj;
42683 fail:
42684 return NULL;
42685 }
42686
42687
42688 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42689 PyObject *resultobj = 0;
42690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42691 int arg2 ;
42692 void *argp1 = 0 ;
42693 int res1 = 0 ;
42694 int val2 ;
42695 int ecode2 = 0 ;
42696 PyObject * obj0 = 0 ;
42697 PyObject * obj1 = 0 ;
42698 char * kwnames[] = {
42699 (char *) "self",(char *) "id", NULL
42700 };
42701
42702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42704 if (!SWIG_IsOK(res1)) {
42705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42706 }
42707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42708 ecode2 = SWIG_AsVal_int(obj1, &val2);
42709 if (!SWIG_IsOK(ecode2)) {
42710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42711 }
42712 arg2 = static_cast< int >(val2);
42713 {
42714 PyThreadState* __tstate = wxPyBeginAllowThreads();
42715 (arg1)->SetId(arg2);
42716 wxPyEndAllowThreads(__tstate);
42717 if (PyErr_Occurred()) SWIG_fail;
42718 }
42719 resultobj = SWIG_Py_Void();
42720 return resultobj;
42721 fail:
42722 return NULL;
42723 }
42724
42725
42726 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42727 PyObject *resultobj = 0;
42728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42729 int result;
42730 void *argp1 = 0 ;
42731 int res1 = 0 ;
42732 PyObject *swig_obj[1] ;
42733
42734 if (!args) SWIG_fail;
42735 swig_obj[0] = args;
42736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42737 if (!SWIG_IsOK(res1)) {
42738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42739 }
42740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42741 {
42742 PyThreadState* __tstate = wxPyBeginAllowThreads();
42743 result = (int)((wxMenuItem const *)arg1)->GetId();
42744 wxPyEndAllowThreads(__tstate);
42745 if (PyErr_Occurred()) SWIG_fail;
42746 }
42747 resultobj = SWIG_From_int(static_cast< int >(result));
42748 return resultobj;
42749 fail:
42750 return NULL;
42751 }
42752
42753
42754 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42755 PyObject *resultobj = 0;
42756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42757 bool result;
42758 void *argp1 = 0 ;
42759 int res1 = 0 ;
42760 PyObject *swig_obj[1] ;
42761
42762 if (!args) SWIG_fail;
42763 swig_obj[0] = args;
42764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42765 if (!SWIG_IsOK(res1)) {
42766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42767 }
42768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42772 wxPyEndAllowThreads(__tstate);
42773 if (PyErr_Occurred()) SWIG_fail;
42774 }
42775 {
42776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42777 }
42778 return resultobj;
42779 fail:
42780 return NULL;
42781 }
42782
42783
42784 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42785 PyObject *resultobj = 0;
42786 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42787 wxString *arg2 = 0 ;
42788 void *argp1 = 0 ;
42789 int res1 = 0 ;
42790 bool temp2 = false ;
42791 PyObject * obj0 = 0 ;
42792 PyObject * obj1 = 0 ;
42793 char * kwnames[] = {
42794 (char *) "self",(char *) "str", NULL
42795 };
42796
42797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42799 if (!SWIG_IsOK(res1)) {
42800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42801 }
42802 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42803 {
42804 arg2 = wxString_in_helper(obj1);
42805 if (arg2 == NULL) SWIG_fail;
42806 temp2 = true;
42807 }
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 (arg1)->SetText((wxString const &)*arg2);
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 resultobj = SWIG_Py_Void();
42815 {
42816 if (temp2)
42817 delete arg2;
42818 }
42819 return resultobj;
42820 fail:
42821 {
42822 if (temp2)
42823 delete arg2;
42824 }
42825 return NULL;
42826 }
42827
42828
42829 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42830 PyObject *resultobj = 0;
42831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42832 wxString result;
42833 void *argp1 = 0 ;
42834 int res1 = 0 ;
42835 PyObject *swig_obj[1] ;
42836
42837 if (!args) SWIG_fail;
42838 swig_obj[0] = args;
42839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42840 if (!SWIG_IsOK(res1)) {
42841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42842 }
42843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42844 {
42845 PyThreadState* __tstate = wxPyBeginAllowThreads();
42846 result = ((wxMenuItem const *)arg1)->GetLabel();
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 {
42851 #if wxUSE_UNICODE
42852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42853 #else
42854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42855 #endif
42856 }
42857 return resultobj;
42858 fail:
42859 return NULL;
42860 }
42861
42862
42863 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42864 PyObject *resultobj = 0;
42865 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42866 wxString *result = 0 ;
42867 void *argp1 = 0 ;
42868 int res1 = 0 ;
42869 PyObject *swig_obj[1] ;
42870
42871 if (!args) SWIG_fail;
42872 swig_obj[0] = args;
42873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42874 if (!SWIG_IsOK(res1)) {
42875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42876 }
42877 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 {
42881 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42882 result = (wxString *) &_result_ref;
42883 }
42884 wxPyEndAllowThreads(__tstate);
42885 if (PyErr_Occurred()) SWIG_fail;
42886 }
42887 {
42888 #if wxUSE_UNICODE
42889 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42890 #else
42891 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42892 #endif
42893 }
42894 return resultobj;
42895 fail:
42896 return NULL;
42897 }
42898
42899
42900 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42901 PyObject *resultobj = 0;
42902 wxString *arg1 = 0 ;
42903 wxString result;
42904 bool temp1 = false ;
42905 PyObject * obj0 = 0 ;
42906 char * kwnames[] = {
42907 (char *) "text", NULL
42908 };
42909
42910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42911 {
42912 arg1 = wxString_in_helper(obj0);
42913 if (arg1 == NULL) SWIG_fail;
42914 temp1 = true;
42915 }
42916 {
42917 PyThreadState* __tstate = wxPyBeginAllowThreads();
42918 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42919 wxPyEndAllowThreads(__tstate);
42920 if (PyErr_Occurred()) SWIG_fail;
42921 }
42922 {
42923 #if wxUSE_UNICODE
42924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42925 #else
42926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42927 #endif
42928 }
42929 {
42930 if (temp1)
42931 delete arg1;
42932 }
42933 return resultobj;
42934 fail:
42935 {
42936 if (temp1)
42937 delete arg1;
42938 }
42939 return NULL;
42940 }
42941
42942
42943 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42944 PyObject *resultobj = 0;
42945 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42946 wxItemKind result;
42947 void *argp1 = 0 ;
42948 int res1 = 0 ;
42949 PyObject *swig_obj[1] ;
42950
42951 if (!args) SWIG_fail;
42952 swig_obj[0] = args;
42953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42954 if (!SWIG_IsOK(res1)) {
42955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42956 }
42957 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42958 {
42959 PyThreadState* __tstate = wxPyBeginAllowThreads();
42960 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42961 wxPyEndAllowThreads(__tstate);
42962 if (PyErr_Occurred()) SWIG_fail;
42963 }
42964 resultobj = SWIG_From_int(static_cast< int >(result));
42965 return resultobj;
42966 fail:
42967 return NULL;
42968 }
42969
42970
42971 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42972 PyObject *resultobj = 0;
42973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42974 wxItemKind arg2 ;
42975 void *argp1 = 0 ;
42976 int res1 = 0 ;
42977 int val2 ;
42978 int ecode2 = 0 ;
42979 PyObject * obj0 = 0 ;
42980 PyObject * obj1 = 0 ;
42981 char * kwnames[] = {
42982 (char *) "self",(char *) "kind", NULL
42983 };
42984
42985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42987 if (!SWIG_IsOK(res1)) {
42988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42989 }
42990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42991 ecode2 = SWIG_AsVal_int(obj1, &val2);
42992 if (!SWIG_IsOK(ecode2)) {
42993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42994 }
42995 arg2 = static_cast< wxItemKind >(val2);
42996 {
42997 PyThreadState* __tstate = wxPyBeginAllowThreads();
42998 (arg1)->SetKind(arg2);
42999 wxPyEndAllowThreads(__tstate);
43000 if (PyErr_Occurred()) SWIG_fail;
43001 }
43002 resultobj = SWIG_Py_Void();
43003 return resultobj;
43004 fail:
43005 return NULL;
43006 }
43007
43008
43009 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43010 PyObject *resultobj = 0;
43011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43012 bool arg2 ;
43013 void *argp1 = 0 ;
43014 int res1 = 0 ;
43015 bool val2 ;
43016 int ecode2 = 0 ;
43017 PyObject * obj0 = 0 ;
43018 PyObject * obj1 = 0 ;
43019 char * kwnames[] = {
43020 (char *) "self",(char *) "checkable", NULL
43021 };
43022
43023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43025 if (!SWIG_IsOK(res1)) {
43026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43027 }
43028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43030 if (!SWIG_IsOK(ecode2)) {
43031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43032 }
43033 arg2 = static_cast< bool >(val2);
43034 {
43035 PyThreadState* __tstate = wxPyBeginAllowThreads();
43036 (arg1)->SetCheckable(arg2);
43037 wxPyEndAllowThreads(__tstate);
43038 if (PyErr_Occurred()) SWIG_fail;
43039 }
43040 resultobj = SWIG_Py_Void();
43041 return resultobj;
43042 fail:
43043 return NULL;
43044 }
43045
43046
43047 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43048 PyObject *resultobj = 0;
43049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43050 bool result;
43051 void *argp1 = 0 ;
43052 int res1 = 0 ;
43053 PyObject *swig_obj[1] ;
43054
43055 if (!args) SWIG_fail;
43056 swig_obj[0] = args;
43057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43058 if (!SWIG_IsOK(res1)) {
43059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43060 }
43061 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43062 {
43063 PyThreadState* __tstate = wxPyBeginAllowThreads();
43064 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43065 wxPyEndAllowThreads(__tstate);
43066 if (PyErr_Occurred()) SWIG_fail;
43067 }
43068 {
43069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43070 }
43071 return resultobj;
43072 fail:
43073 return NULL;
43074 }
43075
43076
43077 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43078 PyObject *resultobj = 0;
43079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43080 bool result;
43081 void *argp1 = 0 ;
43082 int res1 = 0 ;
43083 PyObject *swig_obj[1] ;
43084
43085 if (!args) SWIG_fail;
43086 swig_obj[0] = args;
43087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43088 if (!SWIG_IsOK(res1)) {
43089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43090 }
43091 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43092 {
43093 PyThreadState* __tstate = wxPyBeginAllowThreads();
43094 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43095 wxPyEndAllowThreads(__tstate);
43096 if (PyErr_Occurred()) SWIG_fail;
43097 }
43098 {
43099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43100 }
43101 return resultobj;
43102 fail:
43103 return NULL;
43104 }
43105
43106
43107 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43108 PyObject *resultobj = 0;
43109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43110 wxMenu *arg2 = (wxMenu *) 0 ;
43111 void *argp1 = 0 ;
43112 int res1 = 0 ;
43113 void *argp2 = 0 ;
43114 int res2 = 0 ;
43115 PyObject * obj0 = 0 ;
43116 PyObject * obj1 = 0 ;
43117 char * kwnames[] = {
43118 (char *) "self",(char *) "menu", NULL
43119 };
43120
43121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43123 if (!SWIG_IsOK(res1)) {
43124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43125 }
43126 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43128 if (!SWIG_IsOK(res2)) {
43129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43130 }
43131 arg2 = reinterpret_cast< wxMenu * >(argp2);
43132 {
43133 PyThreadState* __tstate = wxPyBeginAllowThreads();
43134 (arg1)->SetSubMenu(arg2);
43135 wxPyEndAllowThreads(__tstate);
43136 if (PyErr_Occurred()) SWIG_fail;
43137 }
43138 resultobj = SWIG_Py_Void();
43139 return resultobj;
43140 fail:
43141 return NULL;
43142 }
43143
43144
43145 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43146 PyObject *resultobj = 0;
43147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43148 wxMenu *result = 0 ;
43149 void *argp1 = 0 ;
43150 int res1 = 0 ;
43151 PyObject *swig_obj[1] ;
43152
43153 if (!args) SWIG_fail;
43154 swig_obj[0] = args;
43155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43156 if (!SWIG_IsOK(res1)) {
43157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43158 }
43159 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43160 {
43161 PyThreadState* __tstate = wxPyBeginAllowThreads();
43162 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43163 wxPyEndAllowThreads(__tstate);
43164 if (PyErr_Occurred()) SWIG_fail;
43165 }
43166 {
43167 resultobj = wxPyMake_wxObject(result, 0);
43168 }
43169 return resultobj;
43170 fail:
43171 return NULL;
43172 }
43173
43174
43175 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43176 PyObject *resultobj = 0;
43177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43178 bool arg2 = (bool) true ;
43179 void *argp1 = 0 ;
43180 int res1 = 0 ;
43181 bool val2 ;
43182 int ecode2 = 0 ;
43183 PyObject * obj0 = 0 ;
43184 PyObject * obj1 = 0 ;
43185 char * kwnames[] = {
43186 (char *) "self",(char *) "enable", NULL
43187 };
43188
43189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43191 if (!SWIG_IsOK(res1)) {
43192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43193 }
43194 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43195 if (obj1) {
43196 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43197 if (!SWIG_IsOK(ecode2)) {
43198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43199 }
43200 arg2 = static_cast< bool >(val2);
43201 }
43202 {
43203 PyThreadState* __tstate = wxPyBeginAllowThreads();
43204 (arg1)->Enable(arg2);
43205 wxPyEndAllowThreads(__tstate);
43206 if (PyErr_Occurred()) SWIG_fail;
43207 }
43208 resultobj = SWIG_Py_Void();
43209 return resultobj;
43210 fail:
43211 return NULL;
43212 }
43213
43214
43215 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43216 PyObject *resultobj = 0;
43217 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43218 bool result;
43219 void *argp1 = 0 ;
43220 int res1 = 0 ;
43221 PyObject *swig_obj[1] ;
43222
43223 if (!args) SWIG_fail;
43224 swig_obj[0] = args;
43225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43226 if (!SWIG_IsOK(res1)) {
43227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43228 }
43229 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43230 {
43231 PyThreadState* __tstate = wxPyBeginAllowThreads();
43232 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43233 wxPyEndAllowThreads(__tstate);
43234 if (PyErr_Occurred()) SWIG_fail;
43235 }
43236 {
43237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43238 }
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43246 PyObject *resultobj = 0;
43247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43248 bool arg2 = (bool) true ;
43249 void *argp1 = 0 ;
43250 int res1 = 0 ;
43251 bool val2 ;
43252 int ecode2 = 0 ;
43253 PyObject * obj0 = 0 ;
43254 PyObject * obj1 = 0 ;
43255 char * kwnames[] = {
43256 (char *) "self",(char *) "check", NULL
43257 };
43258
43259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43261 if (!SWIG_IsOK(res1)) {
43262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43263 }
43264 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43265 if (obj1) {
43266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43267 if (!SWIG_IsOK(ecode2)) {
43268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43269 }
43270 arg2 = static_cast< bool >(val2);
43271 }
43272 {
43273 PyThreadState* __tstate = wxPyBeginAllowThreads();
43274 (arg1)->Check(arg2);
43275 wxPyEndAllowThreads(__tstate);
43276 if (PyErr_Occurred()) SWIG_fail;
43277 }
43278 resultobj = SWIG_Py_Void();
43279 return resultobj;
43280 fail:
43281 return NULL;
43282 }
43283
43284
43285 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43286 PyObject *resultobj = 0;
43287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43288 bool result;
43289 void *argp1 = 0 ;
43290 int res1 = 0 ;
43291 PyObject *swig_obj[1] ;
43292
43293 if (!args) SWIG_fail;
43294 swig_obj[0] = args;
43295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43296 if (!SWIG_IsOK(res1)) {
43297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43298 }
43299 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43300 {
43301 PyThreadState* __tstate = wxPyBeginAllowThreads();
43302 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43303 wxPyEndAllowThreads(__tstate);
43304 if (PyErr_Occurred()) SWIG_fail;
43305 }
43306 {
43307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43308 }
43309 return resultobj;
43310 fail:
43311 return NULL;
43312 }
43313
43314
43315 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43316 PyObject *resultobj = 0;
43317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43318 void *argp1 = 0 ;
43319 int res1 = 0 ;
43320 PyObject *swig_obj[1] ;
43321
43322 if (!args) SWIG_fail;
43323 swig_obj[0] = args;
43324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43325 if (!SWIG_IsOK(res1)) {
43326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43327 }
43328 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43329 {
43330 PyThreadState* __tstate = wxPyBeginAllowThreads();
43331 (arg1)->Toggle();
43332 wxPyEndAllowThreads(__tstate);
43333 if (PyErr_Occurred()) SWIG_fail;
43334 }
43335 resultobj = SWIG_Py_Void();
43336 return resultobj;
43337 fail:
43338 return NULL;
43339 }
43340
43341
43342 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43343 PyObject *resultobj = 0;
43344 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43345 wxString *arg2 = 0 ;
43346 void *argp1 = 0 ;
43347 int res1 = 0 ;
43348 bool temp2 = false ;
43349 PyObject * obj0 = 0 ;
43350 PyObject * obj1 = 0 ;
43351 char * kwnames[] = {
43352 (char *) "self",(char *) "str", NULL
43353 };
43354
43355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43357 if (!SWIG_IsOK(res1)) {
43358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43359 }
43360 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43361 {
43362 arg2 = wxString_in_helper(obj1);
43363 if (arg2 == NULL) SWIG_fail;
43364 temp2 = true;
43365 }
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 (arg1)->SetHelp((wxString const &)*arg2);
43369 wxPyEndAllowThreads(__tstate);
43370 if (PyErr_Occurred()) SWIG_fail;
43371 }
43372 resultobj = SWIG_Py_Void();
43373 {
43374 if (temp2)
43375 delete arg2;
43376 }
43377 return resultobj;
43378 fail:
43379 {
43380 if (temp2)
43381 delete arg2;
43382 }
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43388 PyObject *resultobj = 0;
43389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43390 wxString *result = 0 ;
43391 void *argp1 = 0 ;
43392 int res1 = 0 ;
43393 PyObject *swig_obj[1] ;
43394
43395 if (!args) SWIG_fail;
43396 swig_obj[0] = args;
43397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43398 if (!SWIG_IsOK(res1)) {
43399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43400 }
43401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43402 {
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 {
43405 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43406 result = (wxString *) &_result_ref;
43407 }
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 {
43412 #if wxUSE_UNICODE
43413 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43414 #else
43415 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43416 #endif
43417 }
43418 return resultobj;
43419 fail:
43420 return NULL;
43421 }
43422
43423
43424 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43425 PyObject *resultobj = 0;
43426 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43427 wxAcceleratorEntry *result = 0 ;
43428 void *argp1 = 0 ;
43429 int res1 = 0 ;
43430 PyObject *swig_obj[1] ;
43431
43432 if (!args) SWIG_fail;
43433 swig_obj[0] = args;
43434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43435 if (!SWIG_IsOK(res1)) {
43436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43437 }
43438 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43439 {
43440 PyThreadState* __tstate = wxPyBeginAllowThreads();
43441 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43442 wxPyEndAllowThreads(__tstate);
43443 if (PyErr_Occurred()) SWIG_fail;
43444 }
43445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43446 return resultobj;
43447 fail:
43448 return NULL;
43449 }
43450
43451
43452 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43453 PyObject *resultobj = 0;
43454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43455 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43456 void *argp1 = 0 ;
43457 int res1 = 0 ;
43458 void *argp2 = 0 ;
43459 int res2 = 0 ;
43460 PyObject * obj0 = 0 ;
43461 PyObject * obj1 = 0 ;
43462 char * kwnames[] = {
43463 (char *) "self",(char *) "accel", NULL
43464 };
43465
43466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43468 if (!SWIG_IsOK(res1)) {
43469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43470 }
43471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43473 if (!SWIG_IsOK(res2)) {
43474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43475 }
43476 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43477 {
43478 PyThreadState* __tstate = wxPyBeginAllowThreads();
43479 (arg1)->SetAccel(arg2);
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 resultobj = SWIG_Py_Void();
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj = 0;
43492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43493 wxBitmap *arg2 = 0 ;
43494 void *argp1 = 0 ;
43495 int res1 = 0 ;
43496 void *argp2 = 0 ;
43497 int res2 = 0 ;
43498 PyObject * obj0 = 0 ;
43499 PyObject * obj1 = 0 ;
43500 char * kwnames[] = {
43501 (char *) "self",(char *) "bitmap", NULL
43502 };
43503
43504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res1)) {
43507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43508 }
43509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43511 if (!SWIG_IsOK(res2)) {
43512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43513 }
43514 if (!argp2) {
43515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43516 }
43517 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43518 {
43519 PyThreadState* __tstate = wxPyBeginAllowThreads();
43520 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43521 wxPyEndAllowThreads(__tstate);
43522 if (PyErr_Occurred()) SWIG_fail;
43523 }
43524 resultobj = SWIG_Py_Void();
43525 return resultobj;
43526 fail:
43527 return NULL;
43528 }
43529
43530
43531 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43532 PyObject *resultobj = 0;
43533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43534 wxBitmap *result = 0 ;
43535 void *argp1 = 0 ;
43536 int res1 = 0 ;
43537 PyObject *swig_obj[1] ;
43538
43539 if (!args) SWIG_fail;
43540 swig_obj[0] = args;
43541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43542 if (!SWIG_IsOK(res1)) {
43543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43544 }
43545 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43546 {
43547 PyThreadState* __tstate = wxPyBeginAllowThreads();
43548 {
43549 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43550 result = (wxBitmap *) &_result_ref;
43551 }
43552 wxPyEndAllowThreads(__tstate);
43553 if (PyErr_Occurred()) SWIG_fail;
43554 }
43555 {
43556 wxBitmap* resultptr = new wxBitmap(*result);
43557 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43558 }
43559 return resultobj;
43560 fail:
43561 return NULL;
43562 }
43563
43564
43565 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43566 PyObject *resultobj = 0;
43567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43568 wxFont *arg2 = 0 ;
43569 void *argp1 = 0 ;
43570 int res1 = 0 ;
43571 void *argp2 = 0 ;
43572 int res2 = 0 ;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575 char * kwnames[] = {
43576 (char *) "self",(char *) "font", NULL
43577 };
43578
43579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43581 if (!SWIG_IsOK(res1)) {
43582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43583 }
43584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43585 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43586 if (!SWIG_IsOK(res2)) {
43587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43588 }
43589 if (!argp2) {
43590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43591 }
43592 arg2 = reinterpret_cast< wxFont * >(argp2);
43593 {
43594 PyThreadState* __tstate = wxPyBeginAllowThreads();
43595 (arg1)->SetFont((wxFont const &)*arg2);
43596 wxPyEndAllowThreads(__tstate);
43597 if (PyErr_Occurred()) SWIG_fail;
43598 }
43599 resultobj = SWIG_Py_Void();
43600 return resultobj;
43601 fail:
43602 return NULL;
43603 }
43604
43605
43606 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43607 PyObject *resultobj = 0;
43608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43609 wxFont result;
43610 void *argp1 = 0 ;
43611 int res1 = 0 ;
43612 PyObject *swig_obj[1] ;
43613
43614 if (!args) SWIG_fail;
43615 swig_obj[0] = args;
43616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43617 if (!SWIG_IsOK(res1)) {
43618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43619 }
43620 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 result = (arg1)->GetFont();
43624 wxPyEndAllowThreads(__tstate);
43625 if (PyErr_Occurred()) SWIG_fail;
43626 }
43627 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj = 0;
43636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43637 wxColour *arg2 = 0 ;
43638 void *argp1 = 0 ;
43639 int res1 = 0 ;
43640 wxColour temp2 ;
43641 PyObject * obj0 = 0 ;
43642 PyObject * obj1 = 0 ;
43643 char * kwnames[] = {
43644 (char *) "self",(char *) "colText", NULL
43645 };
43646
43647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43649 if (!SWIG_IsOK(res1)) {
43650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43651 }
43652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43653 {
43654 arg2 = &temp2;
43655 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43656 }
43657 {
43658 PyThreadState* __tstate = wxPyBeginAllowThreads();
43659 (arg1)->SetTextColour((wxColour const &)*arg2);
43660 wxPyEndAllowThreads(__tstate);
43661 if (PyErr_Occurred()) SWIG_fail;
43662 }
43663 resultobj = SWIG_Py_Void();
43664 return resultobj;
43665 fail:
43666 return NULL;
43667 }
43668
43669
43670 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43671 PyObject *resultobj = 0;
43672 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43673 wxColour result;
43674 void *argp1 = 0 ;
43675 int res1 = 0 ;
43676 PyObject *swig_obj[1] ;
43677
43678 if (!args) SWIG_fail;
43679 swig_obj[0] = args;
43680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43681 if (!SWIG_IsOK(res1)) {
43682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43683 }
43684 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43685 {
43686 PyThreadState* __tstate = wxPyBeginAllowThreads();
43687 result = (arg1)->GetTextColour();
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43692 return resultobj;
43693 fail:
43694 return NULL;
43695 }
43696
43697
43698 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43699 PyObject *resultobj = 0;
43700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43701 wxColour *arg2 = 0 ;
43702 void *argp1 = 0 ;
43703 int res1 = 0 ;
43704 wxColour temp2 ;
43705 PyObject * obj0 = 0 ;
43706 PyObject * obj1 = 0 ;
43707 char * kwnames[] = {
43708 (char *) "self",(char *) "colBack", NULL
43709 };
43710
43711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43713 if (!SWIG_IsOK(res1)) {
43714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43715 }
43716 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43717 {
43718 arg2 = &temp2;
43719 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43720 }
43721 {
43722 PyThreadState* __tstate = wxPyBeginAllowThreads();
43723 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43724 wxPyEndAllowThreads(__tstate);
43725 if (PyErr_Occurred()) SWIG_fail;
43726 }
43727 resultobj = SWIG_Py_Void();
43728 return resultobj;
43729 fail:
43730 return NULL;
43731 }
43732
43733
43734 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43735 PyObject *resultobj = 0;
43736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43737 wxColour result;
43738 void *argp1 = 0 ;
43739 int res1 = 0 ;
43740 PyObject *swig_obj[1] ;
43741
43742 if (!args) SWIG_fail;
43743 swig_obj[0] = args;
43744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43745 if (!SWIG_IsOK(res1)) {
43746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43747 }
43748 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43749 {
43750 PyThreadState* __tstate = wxPyBeginAllowThreads();
43751 result = (arg1)->GetBackgroundColour();
43752 wxPyEndAllowThreads(__tstate);
43753 if (PyErr_Occurred()) SWIG_fail;
43754 }
43755 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43756 return resultobj;
43757 fail:
43758 return NULL;
43759 }
43760
43761
43762 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43763 PyObject *resultobj = 0;
43764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43765 wxBitmap *arg2 = 0 ;
43766 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43767 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43768 void *argp1 = 0 ;
43769 int res1 = 0 ;
43770 void *argp2 = 0 ;
43771 int res2 = 0 ;
43772 void *argp3 = 0 ;
43773 int res3 = 0 ;
43774 PyObject * obj0 = 0 ;
43775 PyObject * obj1 = 0 ;
43776 PyObject * obj2 = 0 ;
43777 char * kwnames[] = {
43778 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43779 };
43780
43781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43783 if (!SWIG_IsOK(res1)) {
43784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43785 }
43786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43788 if (!SWIG_IsOK(res2)) {
43789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43790 }
43791 if (!argp2) {
43792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43793 }
43794 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43795 if (obj2) {
43796 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43797 if (!SWIG_IsOK(res3)) {
43798 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43799 }
43800 if (!argp3) {
43801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43802 }
43803 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43804 }
43805 {
43806 PyThreadState* __tstate = wxPyBeginAllowThreads();
43807 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43808 wxPyEndAllowThreads(__tstate);
43809 if (PyErr_Occurred()) SWIG_fail;
43810 }
43811 resultobj = SWIG_Py_Void();
43812 return resultobj;
43813 fail:
43814 return NULL;
43815 }
43816
43817
43818 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43819 PyObject *resultobj = 0;
43820 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43821 wxBitmap *arg2 = 0 ;
43822 void *argp1 = 0 ;
43823 int res1 = 0 ;
43824 void *argp2 = 0 ;
43825 int res2 = 0 ;
43826 PyObject * obj0 = 0 ;
43827 PyObject * obj1 = 0 ;
43828 char * kwnames[] = {
43829 (char *) "self",(char *) "bmpDisabled", NULL
43830 };
43831
43832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43834 if (!SWIG_IsOK(res1)) {
43835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43836 }
43837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43839 if (!SWIG_IsOK(res2)) {
43840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43841 }
43842 if (!argp2) {
43843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43844 }
43845 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43846 {
43847 PyThreadState* __tstate = wxPyBeginAllowThreads();
43848 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43849 wxPyEndAllowThreads(__tstate);
43850 if (PyErr_Occurred()) SWIG_fail;
43851 }
43852 resultobj = SWIG_Py_Void();
43853 return resultobj;
43854 fail:
43855 return NULL;
43856 }
43857
43858
43859 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43860 PyObject *resultobj = 0;
43861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43862 wxBitmap *result = 0 ;
43863 void *argp1 = 0 ;
43864 int res1 = 0 ;
43865 PyObject *swig_obj[1] ;
43866
43867 if (!args) SWIG_fail;
43868 swig_obj[0] = args;
43869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43870 if (!SWIG_IsOK(res1)) {
43871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43872 }
43873 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43874 {
43875 PyThreadState* __tstate = wxPyBeginAllowThreads();
43876 {
43877 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43878 result = (wxBitmap *) &_result_ref;
43879 }
43880 wxPyEndAllowThreads(__tstate);
43881 if (PyErr_Occurred()) SWIG_fail;
43882 }
43883 {
43884 wxBitmap* resultptr = new wxBitmap(*result);
43885 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43886 }
43887 return resultobj;
43888 fail:
43889 return NULL;
43890 }
43891
43892
43893 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43894 PyObject *resultobj = 0;
43895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43896 int arg2 ;
43897 void *argp1 = 0 ;
43898 int res1 = 0 ;
43899 int val2 ;
43900 int ecode2 = 0 ;
43901 PyObject * obj0 = 0 ;
43902 PyObject * obj1 = 0 ;
43903 char * kwnames[] = {
43904 (char *) "self",(char *) "nWidth", NULL
43905 };
43906
43907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43909 if (!SWIG_IsOK(res1)) {
43910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43911 }
43912 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43913 ecode2 = SWIG_AsVal_int(obj1, &val2);
43914 if (!SWIG_IsOK(ecode2)) {
43915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43916 }
43917 arg2 = static_cast< int >(val2);
43918 {
43919 PyThreadState* __tstate = wxPyBeginAllowThreads();
43920 (arg1)->SetMarginWidth(arg2);
43921 wxPyEndAllowThreads(__tstate);
43922 if (PyErr_Occurred()) SWIG_fail;
43923 }
43924 resultobj = SWIG_Py_Void();
43925 return resultobj;
43926 fail:
43927 return NULL;
43928 }
43929
43930
43931 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43932 PyObject *resultobj = 0;
43933 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43934 int result;
43935 void *argp1 = 0 ;
43936 int res1 = 0 ;
43937 PyObject *swig_obj[1] ;
43938
43939 if (!args) SWIG_fail;
43940 swig_obj[0] = args;
43941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43942 if (!SWIG_IsOK(res1)) {
43943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43944 }
43945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43946 {
43947 PyThreadState* __tstate = wxPyBeginAllowThreads();
43948 result = (int)(arg1)->GetMarginWidth();
43949 wxPyEndAllowThreads(__tstate);
43950 if (PyErr_Occurred()) SWIG_fail;
43951 }
43952 resultobj = SWIG_From_int(static_cast< int >(result));
43953 return resultobj;
43954 fail:
43955 return NULL;
43956 }
43957
43958
43959 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43960 PyObject *resultobj = 0;
43961 int result;
43962
43963 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43964 {
43965 PyThreadState* __tstate = wxPyBeginAllowThreads();
43966 result = (int)wxMenuItem::GetDefaultMarginWidth();
43967 wxPyEndAllowThreads(__tstate);
43968 if (PyErr_Occurred()) SWIG_fail;
43969 }
43970 resultobj = SWIG_From_int(static_cast< int >(result));
43971 return resultobj;
43972 fail:
43973 return NULL;
43974 }
43975
43976
43977 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43978 PyObject *resultobj = 0;
43979 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43980 bool result;
43981 void *argp1 = 0 ;
43982 int res1 = 0 ;
43983 PyObject *swig_obj[1] ;
43984
43985 if (!args) SWIG_fail;
43986 swig_obj[0] = args;
43987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43988 if (!SWIG_IsOK(res1)) {
43989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43990 }
43991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43992 {
43993 PyThreadState* __tstate = wxPyBeginAllowThreads();
43994 result = (bool)(arg1)->IsOwnerDrawn();
43995 wxPyEndAllowThreads(__tstate);
43996 if (PyErr_Occurred()) SWIG_fail;
43997 }
43998 {
43999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44000 }
44001 return resultobj;
44002 fail:
44003 return NULL;
44004 }
44005
44006
44007 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44008 PyObject *resultobj = 0;
44009 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44010 bool arg2 = (bool) true ;
44011 void *argp1 = 0 ;
44012 int res1 = 0 ;
44013 bool val2 ;
44014 int ecode2 = 0 ;
44015 PyObject * obj0 = 0 ;
44016 PyObject * obj1 = 0 ;
44017 char * kwnames[] = {
44018 (char *) "self",(char *) "ownerDrawn", NULL
44019 };
44020
44021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44023 if (!SWIG_IsOK(res1)) {
44024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44025 }
44026 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44027 if (obj1) {
44028 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44029 if (!SWIG_IsOK(ecode2)) {
44030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44031 }
44032 arg2 = static_cast< bool >(val2);
44033 }
44034 {
44035 PyThreadState* __tstate = wxPyBeginAllowThreads();
44036 (arg1)->SetOwnerDrawn(arg2);
44037 wxPyEndAllowThreads(__tstate);
44038 if (PyErr_Occurred()) SWIG_fail;
44039 }
44040 resultobj = SWIG_Py_Void();
44041 return resultobj;
44042 fail:
44043 return NULL;
44044 }
44045
44046
44047 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44048 PyObject *resultobj = 0;
44049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44050 void *argp1 = 0 ;
44051 int res1 = 0 ;
44052 PyObject *swig_obj[1] ;
44053
44054 if (!args) SWIG_fail;
44055 swig_obj[0] = args;
44056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44057 if (!SWIG_IsOK(res1)) {
44058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44059 }
44060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44061 {
44062 PyThreadState* __tstate = wxPyBeginAllowThreads();
44063 (arg1)->ResetOwnerDrawn();
44064 wxPyEndAllowThreads(__tstate);
44065 if (PyErr_Occurred()) SWIG_fail;
44066 }
44067 resultobj = SWIG_Py_Void();
44068 return resultobj;
44069 fail:
44070 return NULL;
44071 }
44072
44073
44074 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44075 PyObject *obj;
44076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44077 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44078 return SWIG_Py_Void();
44079 }
44080
44081 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44082 return SWIG_Python_InitShadowInstance(args);
44083 }
44084
44085 SWIGINTERN int ControlNameStr_set(PyObject *) {
44086 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44087 return 1;
44088 }
44089
44090
44091 SWIGINTERN PyObject *ControlNameStr_get(void) {
44092 PyObject *pyobj = 0;
44093
44094 {
44095 #if wxUSE_UNICODE
44096 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44097 #else
44098 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44099 #endif
44100 }
44101 return pyobj;
44102 }
44103
44104
44105 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44106 PyObject *resultobj = 0;
44107 wxWindow *arg1 = (wxWindow *) 0 ;
44108 int arg2 = (int) -1 ;
44109 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44110 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44111 wxSize const &arg4_defvalue = wxDefaultSize ;
44112 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44113 long arg5 = (long) 0 ;
44114 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44115 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44116 wxString const &arg7_defvalue = wxPyControlNameStr ;
44117 wxString *arg7 = (wxString *) &arg7_defvalue ;
44118 wxControl *result = 0 ;
44119 void *argp1 = 0 ;
44120 int res1 = 0 ;
44121 int val2 ;
44122 int ecode2 = 0 ;
44123 wxPoint temp3 ;
44124 wxSize temp4 ;
44125 long val5 ;
44126 int ecode5 = 0 ;
44127 void *argp6 = 0 ;
44128 int res6 = 0 ;
44129 bool temp7 = false ;
44130 PyObject * obj0 = 0 ;
44131 PyObject * obj1 = 0 ;
44132 PyObject * obj2 = 0 ;
44133 PyObject * obj3 = 0 ;
44134 PyObject * obj4 = 0 ;
44135 PyObject * obj5 = 0 ;
44136 PyObject * obj6 = 0 ;
44137 char * kwnames[] = {
44138 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44139 };
44140
44141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44143 if (!SWIG_IsOK(res1)) {
44144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44145 }
44146 arg1 = reinterpret_cast< wxWindow * >(argp1);
44147 if (obj1) {
44148 ecode2 = SWIG_AsVal_int(obj1, &val2);
44149 if (!SWIG_IsOK(ecode2)) {
44150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44151 }
44152 arg2 = static_cast< int >(val2);
44153 }
44154 if (obj2) {
44155 {
44156 arg3 = &temp3;
44157 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44158 }
44159 }
44160 if (obj3) {
44161 {
44162 arg4 = &temp4;
44163 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44164 }
44165 }
44166 if (obj4) {
44167 ecode5 = SWIG_AsVal_long(obj4, &val5);
44168 if (!SWIG_IsOK(ecode5)) {
44169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44170 }
44171 arg5 = static_cast< long >(val5);
44172 }
44173 if (obj5) {
44174 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44175 if (!SWIG_IsOK(res6)) {
44176 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44177 }
44178 if (!argp6) {
44179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44180 }
44181 arg6 = reinterpret_cast< wxValidator * >(argp6);
44182 }
44183 if (obj6) {
44184 {
44185 arg7 = wxString_in_helper(obj6);
44186 if (arg7 == NULL) SWIG_fail;
44187 temp7 = true;
44188 }
44189 }
44190 {
44191 if (!wxPyCheckForApp()) SWIG_fail;
44192 PyThreadState* __tstate = wxPyBeginAllowThreads();
44193 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44194 wxPyEndAllowThreads(__tstate);
44195 if (PyErr_Occurred()) SWIG_fail;
44196 }
44197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44198 {
44199 if (temp7)
44200 delete arg7;
44201 }
44202 return resultobj;
44203 fail:
44204 {
44205 if (temp7)
44206 delete arg7;
44207 }
44208 return NULL;
44209 }
44210
44211
44212 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44213 PyObject *resultobj = 0;
44214 wxControl *result = 0 ;
44215
44216 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44217 {
44218 if (!wxPyCheckForApp()) SWIG_fail;
44219 PyThreadState* __tstate = wxPyBeginAllowThreads();
44220 result = (wxControl *)new wxControl();
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44232 PyObject *resultobj = 0;
44233 wxControl *arg1 = (wxControl *) 0 ;
44234 wxWindow *arg2 = (wxWindow *) 0 ;
44235 int arg3 = (int) -1 ;
44236 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44237 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44238 wxSize const &arg5_defvalue = wxDefaultSize ;
44239 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44240 long arg6 = (long) 0 ;
44241 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44242 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44243 wxString const &arg8_defvalue = wxPyControlNameStr ;
44244 wxString *arg8 = (wxString *) &arg8_defvalue ;
44245 bool result;
44246 void *argp1 = 0 ;
44247 int res1 = 0 ;
44248 void *argp2 = 0 ;
44249 int res2 = 0 ;
44250 int val3 ;
44251 int ecode3 = 0 ;
44252 wxPoint temp4 ;
44253 wxSize temp5 ;
44254 long val6 ;
44255 int ecode6 = 0 ;
44256 void *argp7 = 0 ;
44257 int res7 = 0 ;
44258 bool temp8 = false ;
44259 PyObject * obj0 = 0 ;
44260 PyObject * obj1 = 0 ;
44261 PyObject * obj2 = 0 ;
44262 PyObject * obj3 = 0 ;
44263 PyObject * obj4 = 0 ;
44264 PyObject * obj5 = 0 ;
44265 PyObject * obj6 = 0 ;
44266 PyObject * obj7 = 0 ;
44267 char * kwnames[] = {
44268 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44269 };
44270
44271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44273 if (!SWIG_IsOK(res1)) {
44274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44275 }
44276 arg1 = reinterpret_cast< wxControl * >(argp1);
44277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44278 if (!SWIG_IsOK(res2)) {
44279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44280 }
44281 arg2 = reinterpret_cast< wxWindow * >(argp2);
44282 if (obj2) {
44283 ecode3 = SWIG_AsVal_int(obj2, &val3);
44284 if (!SWIG_IsOK(ecode3)) {
44285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44286 }
44287 arg3 = static_cast< int >(val3);
44288 }
44289 if (obj3) {
44290 {
44291 arg4 = &temp4;
44292 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44293 }
44294 }
44295 if (obj4) {
44296 {
44297 arg5 = &temp5;
44298 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44299 }
44300 }
44301 if (obj5) {
44302 ecode6 = SWIG_AsVal_long(obj5, &val6);
44303 if (!SWIG_IsOK(ecode6)) {
44304 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44305 }
44306 arg6 = static_cast< long >(val6);
44307 }
44308 if (obj6) {
44309 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44310 if (!SWIG_IsOK(res7)) {
44311 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44312 }
44313 if (!argp7) {
44314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44315 }
44316 arg7 = reinterpret_cast< wxValidator * >(argp7);
44317 }
44318 if (obj7) {
44319 {
44320 arg8 = wxString_in_helper(obj7);
44321 if (arg8 == NULL) SWIG_fail;
44322 temp8 = true;
44323 }
44324 }
44325 {
44326 PyThreadState* __tstate = wxPyBeginAllowThreads();
44327 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44328 wxPyEndAllowThreads(__tstate);
44329 if (PyErr_Occurred()) SWIG_fail;
44330 }
44331 {
44332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44333 }
44334 {
44335 if (temp8)
44336 delete arg8;
44337 }
44338 return resultobj;
44339 fail:
44340 {
44341 if (temp8)
44342 delete arg8;
44343 }
44344 return NULL;
44345 }
44346
44347
44348 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44349 PyObject *resultobj = 0;
44350 wxControl *arg1 = (wxControl *) 0 ;
44351 int result;
44352 void *argp1 = 0 ;
44353 int res1 = 0 ;
44354 PyObject *swig_obj[1] ;
44355
44356 if (!args) SWIG_fail;
44357 swig_obj[0] = args;
44358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44359 if (!SWIG_IsOK(res1)) {
44360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44361 }
44362 arg1 = reinterpret_cast< wxControl * >(argp1);
44363 {
44364 PyThreadState* __tstate = wxPyBeginAllowThreads();
44365 result = (int)((wxControl const *)arg1)->GetAlignment();
44366 wxPyEndAllowThreads(__tstate);
44367 if (PyErr_Occurred()) SWIG_fail;
44368 }
44369 resultobj = SWIG_From_int(static_cast< int >(result));
44370 return resultobj;
44371 fail:
44372 return NULL;
44373 }
44374
44375
44376 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44377 PyObject *resultobj = 0;
44378 wxControl *arg1 = (wxControl *) 0 ;
44379 wxString result;
44380 void *argp1 = 0 ;
44381 int res1 = 0 ;
44382 PyObject *swig_obj[1] ;
44383
44384 if (!args) SWIG_fail;
44385 swig_obj[0] = args;
44386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44387 if (!SWIG_IsOK(res1)) {
44388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44389 }
44390 arg1 = reinterpret_cast< wxControl * >(argp1);
44391 {
44392 PyThreadState* __tstate = wxPyBeginAllowThreads();
44393 result = ((wxControl const *)arg1)->GetLabelText();
44394 wxPyEndAllowThreads(__tstate);
44395 if (PyErr_Occurred()) SWIG_fail;
44396 }
44397 {
44398 #if wxUSE_UNICODE
44399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44400 #else
44401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44402 #endif
44403 }
44404 return resultobj;
44405 fail:
44406 return NULL;
44407 }
44408
44409
44410 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44411 PyObject *resultobj = 0;
44412 wxControl *arg1 = (wxControl *) 0 ;
44413 wxCommandEvent *arg2 = 0 ;
44414 void *argp1 = 0 ;
44415 int res1 = 0 ;
44416 void *argp2 = 0 ;
44417 int res2 = 0 ;
44418 PyObject * obj0 = 0 ;
44419 PyObject * obj1 = 0 ;
44420 char * kwnames[] = {
44421 (char *) "self",(char *) "event", NULL
44422 };
44423
44424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44426 if (!SWIG_IsOK(res1)) {
44427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44428 }
44429 arg1 = reinterpret_cast< wxControl * >(argp1);
44430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44431 if (!SWIG_IsOK(res2)) {
44432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44433 }
44434 if (!argp2) {
44435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44436 }
44437 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44438 {
44439 PyThreadState* __tstate = wxPyBeginAllowThreads();
44440 (arg1)->Command(*arg2);
44441 wxPyEndAllowThreads(__tstate);
44442 if (PyErr_Occurred()) SWIG_fail;
44443 }
44444 resultobj = SWIG_Py_Void();
44445 return resultobj;
44446 fail:
44447 return NULL;
44448 }
44449
44450
44451 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44452 PyObject *resultobj = 0;
44453 wxControl *arg1 = (wxControl *) 0 ;
44454 wxString result;
44455 void *argp1 = 0 ;
44456 int res1 = 0 ;
44457 PyObject *swig_obj[1] ;
44458
44459 if (!args) SWIG_fail;
44460 swig_obj[0] = args;
44461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44462 if (!SWIG_IsOK(res1)) {
44463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44464 }
44465 arg1 = reinterpret_cast< wxControl * >(argp1);
44466 {
44467 PyThreadState* __tstate = wxPyBeginAllowThreads();
44468 result = (arg1)->GetLabel();
44469 wxPyEndAllowThreads(__tstate);
44470 if (PyErr_Occurred()) SWIG_fail;
44471 }
44472 {
44473 #if wxUSE_UNICODE
44474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44475 #else
44476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44477 #endif
44478 }
44479 return resultobj;
44480 fail:
44481 return NULL;
44482 }
44483
44484
44485 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44486 PyObject *resultobj = 0;
44487 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44488 SwigValueWrapper<wxVisualAttributes > result;
44489 int val1 ;
44490 int ecode1 = 0 ;
44491 PyObject * obj0 = 0 ;
44492 char * kwnames[] = {
44493 (char *) "variant", NULL
44494 };
44495
44496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44497 if (obj0) {
44498 ecode1 = SWIG_AsVal_int(obj0, &val1);
44499 if (!SWIG_IsOK(ecode1)) {
44500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44501 }
44502 arg1 = static_cast< wxWindowVariant >(val1);
44503 }
44504 {
44505 if (!wxPyCheckForApp()) SWIG_fail;
44506 PyThreadState* __tstate = wxPyBeginAllowThreads();
44507 result = wxControl::GetClassDefaultAttributes(arg1);
44508 wxPyEndAllowThreads(__tstate);
44509 if (PyErr_Occurred()) SWIG_fail;
44510 }
44511 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44512 return resultobj;
44513 fail:
44514 return NULL;
44515 }
44516
44517
44518 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44519 PyObject *obj;
44520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44521 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44522 return SWIG_Py_Void();
44523 }
44524
44525 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44526 return SWIG_Python_InitShadowInstance(args);
44527 }
44528
44529 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44530 PyObject *resultobj = 0;
44531 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44532 wxString *arg2 = 0 ;
44533 PyObject *arg3 = (PyObject *) NULL ;
44534 int result;
44535 void *argp1 = 0 ;
44536 int res1 = 0 ;
44537 bool temp2 = false ;
44538 PyObject * obj0 = 0 ;
44539 PyObject * obj1 = 0 ;
44540 PyObject * obj2 = 0 ;
44541 char * kwnames[] = {
44542 (char *) "self",(char *) "item",(char *) "clientData", NULL
44543 };
44544
44545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44547 if (!SWIG_IsOK(res1)) {
44548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44549 }
44550 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44551 {
44552 arg2 = wxString_in_helper(obj1);
44553 if (arg2 == NULL) SWIG_fail;
44554 temp2 = true;
44555 }
44556 if (obj2) {
44557 arg3 = obj2;
44558 }
44559 {
44560 PyThreadState* __tstate = wxPyBeginAllowThreads();
44561 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44562 wxPyEndAllowThreads(__tstate);
44563 if (PyErr_Occurred()) SWIG_fail;
44564 }
44565 resultobj = SWIG_From_int(static_cast< int >(result));
44566 {
44567 if (temp2)
44568 delete arg2;
44569 }
44570 return resultobj;
44571 fail:
44572 {
44573 if (temp2)
44574 delete arg2;
44575 }
44576 return NULL;
44577 }
44578
44579
44580 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44581 PyObject *resultobj = 0;
44582 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44583 wxArrayString *arg2 = 0 ;
44584 void *argp1 = 0 ;
44585 int res1 = 0 ;
44586 bool temp2 = false ;
44587 PyObject * obj0 = 0 ;
44588 PyObject * obj1 = 0 ;
44589 char * kwnames[] = {
44590 (char *) "self",(char *) "strings", NULL
44591 };
44592
44593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44595 if (!SWIG_IsOK(res1)) {
44596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44597 }
44598 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44599 {
44600 if (! PySequence_Check(obj1)) {
44601 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44602 SWIG_fail;
44603 }
44604 arg2 = new wxArrayString;
44605 temp2 = true;
44606 int i, len=PySequence_Length(obj1);
44607 for (i=0; i<len; i++) {
44608 PyObject* item = PySequence_GetItem(obj1, i);
44609 wxString* s = wxString_in_helper(item);
44610 if (PyErr_Occurred()) SWIG_fail;
44611 arg2->Add(*s);
44612 delete s;
44613 Py_DECREF(item);
44614 }
44615 }
44616 {
44617 PyThreadState* __tstate = wxPyBeginAllowThreads();
44618 (arg1)->Append((wxArrayString const &)*arg2);
44619 wxPyEndAllowThreads(__tstate);
44620 if (PyErr_Occurred()) SWIG_fail;
44621 }
44622 resultobj = SWIG_Py_Void();
44623 {
44624 if (temp2) delete arg2;
44625 }
44626 return resultobj;
44627 fail:
44628 {
44629 if (temp2) delete arg2;
44630 }
44631 return NULL;
44632 }
44633
44634
44635 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44636 PyObject *resultobj = 0;
44637 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44638 wxString *arg2 = 0 ;
44639 unsigned int arg3 ;
44640 PyObject *arg4 = (PyObject *) NULL ;
44641 int result;
44642 void *argp1 = 0 ;
44643 int res1 = 0 ;
44644 bool temp2 = false ;
44645 unsigned int val3 ;
44646 int ecode3 = 0 ;
44647 PyObject * obj0 = 0 ;
44648 PyObject * obj1 = 0 ;
44649 PyObject * obj2 = 0 ;
44650 PyObject * obj3 = 0 ;
44651 char * kwnames[] = {
44652 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44653 };
44654
44655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44657 if (!SWIG_IsOK(res1)) {
44658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44659 }
44660 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44661 {
44662 arg2 = wxString_in_helper(obj1);
44663 if (arg2 == NULL) SWIG_fail;
44664 temp2 = true;
44665 }
44666 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44667 if (!SWIG_IsOK(ecode3)) {
44668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44669 }
44670 arg3 = static_cast< unsigned int >(val3);
44671 if (obj3) {
44672 arg4 = obj3;
44673 }
44674 {
44675 PyThreadState* __tstate = wxPyBeginAllowThreads();
44676 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44677 wxPyEndAllowThreads(__tstate);
44678 if (PyErr_Occurred()) SWIG_fail;
44679 }
44680 resultobj = SWIG_From_int(static_cast< int >(result));
44681 {
44682 if (temp2)
44683 delete arg2;
44684 }
44685 return resultobj;
44686 fail:
44687 {
44688 if (temp2)
44689 delete arg2;
44690 }
44691 return NULL;
44692 }
44693
44694
44695 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44696 PyObject *resultobj = 0;
44697 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44698 void *argp1 = 0 ;
44699 int res1 = 0 ;
44700 PyObject *swig_obj[1] ;
44701
44702 if (!args) SWIG_fail;
44703 swig_obj[0] = args;
44704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44705 if (!SWIG_IsOK(res1)) {
44706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44707 }
44708 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44709 {
44710 PyThreadState* __tstate = wxPyBeginAllowThreads();
44711 (arg1)->Clear();
44712 wxPyEndAllowThreads(__tstate);
44713 if (PyErr_Occurred()) SWIG_fail;
44714 }
44715 resultobj = SWIG_Py_Void();
44716 return resultobj;
44717 fail:
44718 return NULL;
44719 }
44720
44721
44722 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44723 PyObject *resultobj = 0;
44724 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44725 unsigned int arg2 ;
44726 void *argp1 = 0 ;
44727 int res1 = 0 ;
44728 unsigned int val2 ;
44729 int ecode2 = 0 ;
44730 PyObject * obj0 = 0 ;
44731 PyObject * obj1 = 0 ;
44732 char * kwnames[] = {
44733 (char *) "self",(char *) "n", NULL
44734 };
44735
44736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44738 if (!SWIG_IsOK(res1)) {
44739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44740 }
44741 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44742 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44743 if (!SWIG_IsOK(ecode2)) {
44744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44745 }
44746 arg2 = static_cast< unsigned int >(val2);
44747 {
44748 PyThreadState* __tstate = wxPyBeginAllowThreads();
44749 (arg1)->Delete(arg2);
44750 wxPyEndAllowThreads(__tstate);
44751 if (PyErr_Occurred()) SWIG_fail;
44752 }
44753 resultobj = SWIG_Py_Void();
44754 return resultobj;
44755 fail:
44756 return NULL;
44757 }
44758
44759
44760 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44761 PyObject *resultobj = 0;
44762 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44763 unsigned int arg2 ;
44764 PyObject *result = 0 ;
44765 void *argp1 = 0 ;
44766 int res1 = 0 ;
44767 unsigned int val2 ;
44768 int ecode2 = 0 ;
44769 PyObject * obj0 = 0 ;
44770 PyObject * obj1 = 0 ;
44771 char * kwnames[] = {
44772 (char *) "self",(char *) "n", NULL
44773 };
44774
44775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44777 if (!SWIG_IsOK(res1)) {
44778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44779 }
44780 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44781 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44782 if (!SWIG_IsOK(ecode2)) {
44783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44784 }
44785 arg2 = static_cast< unsigned int >(val2);
44786 {
44787 PyThreadState* __tstate = wxPyBeginAllowThreads();
44788 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44789 wxPyEndAllowThreads(__tstate);
44790 if (PyErr_Occurred()) SWIG_fail;
44791 }
44792 resultobj = result;
44793 return resultobj;
44794 fail:
44795 return NULL;
44796 }
44797
44798
44799 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44800 PyObject *resultobj = 0;
44801 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44802 unsigned int arg2 ;
44803 PyObject *arg3 = (PyObject *) 0 ;
44804 void *argp1 = 0 ;
44805 int res1 = 0 ;
44806 unsigned int val2 ;
44807 int ecode2 = 0 ;
44808 PyObject * obj0 = 0 ;
44809 PyObject * obj1 = 0 ;
44810 PyObject * obj2 = 0 ;
44811 char * kwnames[] = {
44812 (char *) "self",(char *) "n",(char *) "clientData", NULL
44813 };
44814
44815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44817 if (!SWIG_IsOK(res1)) {
44818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44819 }
44820 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44821 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44822 if (!SWIG_IsOK(ecode2)) {
44823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44824 }
44825 arg2 = static_cast< unsigned int >(val2);
44826 arg3 = obj2;
44827 {
44828 PyThreadState* __tstate = wxPyBeginAllowThreads();
44829 wxItemContainer_SetClientData(arg1,arg2,arg3);
44830 wxPyEndAllowThreads(__tstate);
44831 if (PyErr_Occurred()) SWIG_fail;
44832 }
44833 resultobj = SWIG_Py_Void();
44834 return resultobj;
44835 fail:
44836 return NULL;
44837 }
44838
44839
44840 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44841 PyObject *resultobj = 0;
44842 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44843 unsigned int result;
44844 void *argp1 = 0 ;
44845 int res1 = 0 ;
44846 PyObject *swig_obj[1] ;
44847
44848 if (!args) SWIG_fail;
44849 swig_obj[0] = args;
44850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44851 if (!SWIG_IsOK(res1)) {
44852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44853 }
44854 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44855 {
44856 PyThreadState* __tstate = wxPyBeginAllowThreads();
44857 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44858 wxPyEndAllowThreads(__tstate);
44859 if (PyErr_Occurred()) SWIG_fail;
44860 }
44861 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44869 PyObject *resultobj = 0;
44870 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44871 bool result;
44872 void *argp1 = 0 ;
44873 int res1 = 0 ;
44874 PyObject *swig_obj[1] ;
44875
44876 if (!args) SWIG_fail;
44877 swig_obj[0] = args;
44878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44879 if (!SWIG_IsOK(res1)) {
44880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44881 }
44882 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44883 {
44884 PyThreadState* __tstate = wxPyBeginAllowThreads();
44885 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44886 wxPyEndAllowThreads(__tstate);
44887 if (PyErr_Occurred()) SWIG_fail;
44888 }
44889 {
44890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44891 }
44892 return resultobj;
44893 fail:
44894 return NULL;
44895 }
44896
44897
44898 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44899 PyObject *resultobj = 0;
44900 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44901 unsigned int arg2 ;
44902 wxString result;
44903 void *argp1 = 0 ;
44904 int res1 = 0 ;
44905 unsigned int val2 ;
44906 int ecode2 = 0 ;
44907 PyObject * obj0 = 0 ;
44908 PyObject * obj1 = 0 ;
44909 char * kwnames[] = {
44910 (char *) "self",(char *) "n", NULL
44911 };
44912
44913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44915 if (!SWIG_IsOK(res1)) {
44916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44917 }
44918 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44919 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44920 if (!SWIG_IsOK(ecode2)) {
44921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44922 }
44923 arg2 = static_cast< unsigned int >(val2);
44924 {
44925 PyThreadState* __tstate = wxPyBeginAllowThreads();
44926 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44927 wxPyEndAllowThreads(__tstate);
44928 if (PyErr_Occurred()) SWIG_fail;
44929 }
44930 {
44931 #if wxUSE_UNICODE
44932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44933 #else
44934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44935 #endif
44936 }
44937 return resultobj;
44938 fail:
44939 return NULL;
44940 }
44941
44942
44943 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44944 PyObject *resultobj = 0;
44945 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44946 wxArrayString result;
44947 void *argp1 = 0 ;
44948 int res1 = 0 ;
44949 PyObject *swig_obj[1] ;
44950
44951 if (!args) SWIG_fail;
44952 swig_obj[0] = args;
44953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44954 if (!SWIG_IsOK(res1)) {
44955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44956 }
44957 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44958 {
44959 PyThreadState* __tstate = wxPyBeginAllowThreads();
44960 result = ((wxItemContainer const *)arg1)->GetStrings();
44961 wxPyEndAllowThreads(__tstate);
44962 if (PyErr_Occurred()) SWIG_fail;
44963 }
44964 {
44965 resultobj = wxArrayString2PyList_helper(result);
44966 }
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj = 0;
44975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44976 unsigned int arg2 ;
44977 wxString *arg3 = 0 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 unsigned int val2 ;
44981 int ecode2 = 0 ;
44982 bool temp3 = false ;
44983 PyObject * obj0 = 0 ;
44984 PyObject * obj1 = 0 ;
44985 PyObject * obj2 = 0 ;
44986 char * kwnames[] = {
44987 (char *) "self",(char *) "n",(char *) "s", NULL
44988 };
44989
44990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44992 if (!SWIG_IsOK(res1)) {
44993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44994 }
44995 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44996 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44997 if (!SWIG_IsOK(ecode2)) {
44998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44999 }
45000 arg2 = static_cast< unsigned int >(val2);
45001 {
45002 arg3 = wxString_in_helper(obj2);
45003 if (arg3 == NULL) SWIG_fail;
45004 temp3 = true;
45005 }
45006 {
45007 PyThreadState* __tstate = wxPyBeginAllowThreads();
45008 (arg1)->SetString(arg2,(wxString const &)*arg3);
45009 wxPyEndAllowThreads(__tstate);
45010 if (PyErr_Occurred()) SWIG_fail;
45011 }
45012 resultobj = SWIG_Py_Void();
45013 {
45014 if (temp3)
45015 delete arg3;
45016 }
45017 return resultobj;
45018 fail:
45019 {
45020 if (temp3)
45021 delete arg3;
45022 }
45023 return NULL;
45024 }
45025
45026
45027 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45028 PyObject *resultobj = 0;
45029 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45030 wxString *arg2 = 0 ;
45031 int result;
45032 void *argp1 = 0 ;
45033 int res1 = 0 ;
45034 bool temp2 = false ;
45035 PyObject * obj0 = 0 ;
45036 PyObject * obj1 = 0 ;
45037 char * kwnames[] = {
45038 (char *) "self",(char *) "s", NULL
45039 };
45040
45041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45043 if (!SWIG_IsOK(res1)) {
45044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45045 }
45046 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45047 {
45048 arg2 = wxString_in_helper(obj1);
45049 if (arg2 == NULL) SWIG_fail;
45050 temp2 = true;
45051 }
45052 {
45053 PyThreadState* __tstate = wxPyBeginAllowThreads();
45054 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45055 wxPyEndAllowThreads(__tstate);
45056 if (PyErr_Occurred()) SWIG_fail;
45057 }
45058 resultobj = SWIG_From_int(static_cast< int >(result));
45059 {
45060 if (temp2)
45061 delete arg2;
45062 }
45063 return resultobj;
45064 fail:
45065 {
45066 if (temp2)
45067 delete arg2;
45068 }
45069 return NULL;
45070 }
45071
45072
45073 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45074 PyObject *resultobj = 0;
45075 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45076 int arg2 ;
45077 void *argp1 = 0 ;
45078 int res1 = 0 ;
45079 int val2 ;
45080 int ecode2 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 char * kwnames[] = {
45084 (char *) "self",(char *) "n", NULL
45085 };
45086
45087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45089 if (!SWIG_IsOK(res1)) {
45090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45091 }
45092 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45093 ecode2 = SWIG_AsVal_int(obj1, &val2);
45094 if (!SWIG_IsOK(ecode2)) {
45095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45096 }
45097 arg2 = static_cast< int >(val2);
45098 {
45099 PyThreadState* __tstate = wxPyBeginAllowThreads();
45100 (arg1)->SetSelection(arg2);
45101 wxPyEndAllowThreads(__tstate);
45102 if (PyErr_Occurred()) SWIG_fail;
45103 }
45104 resultobj = SWIG_Py_Void();
45105 return resultobj;
45106 fail:
45107 return NULL;
45108 }
45109
45110
45111 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45112 PyObject *resultobj = 0;
45113 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45114 int result;
45115 void *argp1 = 0 ;
45116 int res1 = 0 ;
45117 PyObject *swig_obj[1] ;
45118
45119 if (!args) SWIG_fail;
45120 swig_obj[0] = args;
45121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45122 if (!SWIG_IsOK(res1)) {
45123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45124 }
45125 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45126 {
45127 PyThreadState* __tstate = wxPyBeginAllowThreads();
45128 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45129 wxPyEndAllowThreads(__tstate);
45130 if (PyErr_Occurred()) SWIG_fail;
45131 }
45132 resultobj = SWIG_From_int(static_cast< int >(result));
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj = 0;
45141 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45142 wxString *arg2 = 0 ;
45143 bool result;
45144 void *argp1 = 0 ;
45145 int res1 = 0 ;
45146 bool temp2 = false ;
45147 PyObject * obj0 = 0 ;
45148 PyObject * obj1 = 0 ;
45149 char * kwnames[] = {
45150 (char *) "self",(char *) "s", NULL
45151 };
45152
45153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45155 if (!SWIG_IsOK(res1)) {
45156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45157 }
45158 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45159 {
45160 arg2 = wxString_in_helper(obj1);
45161 if (arg2 == NULL) SWIG_fail;
45162 temp2 = true;
45163 }
45164 {
45165 PyThreadState* __tstate = wxPyBeginAllowThreads();
45166 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45167 wxPyEndAllowThreads(__tstate);
45168 if (PyErr_Occurred()) SWIG_fail;
45169 }
45170 {
45171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45172 }
45173 {
45174 if (temp2)
45175 delete arg2;
45176 }
45177 return resultobj;
45178 fail:
45179 {
45180 if (temp2)
45181 delete arg2;
45182 }
45183 return NULL;
45184 }
45185
45186
45187 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45188 PyObject *resultobj = 0;
45189 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45190 wxString result;
45191 void *argp1 = 0 ;
45192 int res1 = 0 ;
45193 PyObject *swig_obj[1] ;
45194
45195 if (!args) SWIG_fail;
45196 swig_obj[0] = args;
45197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45198 if (!SWIG_IsOK(res1)) {
45199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45200 }
45201 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45202 {
45203 PyThreadState* __tstate = wxPyBeginAllowThreads();
45204 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45205 wxPyEndAllowThreads(__tstate);
45206 if (PyErr_Occurred()) SWIG_fail;
45207 }
45208 {
45209 #if wxUSE_UNICODE
45210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45211 #else
45212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45213 #endif
45214 }
45215 return resultobj;
45216 fail:
45217 return NULL;
45218 }
45219
45220
45221 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45222 PyObject *resultobj = 0;
45223 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45224 int arg2 ;
45225 void *argp1 = 0 ;
45226 int res1 = 0 ;
45227 int val2 ;
45228 int ecode2 = 0 ;
45229 PyObject * obj0 = 0 ;
45230 PyObject * obj1 = 0 ;
45231 char * kwnames[] = {
45232 (char *) "self",(char *) "n", NULL
45233 };
45234
45235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45237 if (!SWIG_IsOK(res1)) {
45238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45239 }
45240 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45241 ecode2 = SWIG_AsVal_int(obj1, &val2);
45242 if (!SWIG_IsOK(ecode2)) {
45243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45244 }
45245 arg2 = static_cast< int >(val2);
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 (arg1)->Select(arg2);
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 resultobj = SWIG_Py_Void();
45253 return resultobj;
45254 fail:
45255 return NULL;
45256 }
45257
45258
45259 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45260 PyObject *obj;
45261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45262 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45263 return SWIG_Py_Void();
45264 }
45265
45266 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45267 PyObject *obj;
45268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45269 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45270 return SWIG_Py_Void();
45271 }
45272
45273 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45274 PyObject *resultobj = 0;
45275 wxSizerItem *result = 0 ;
45276
45277 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45278 {
45279 PyThreadState* __tstate = wxPyBeginAllowThreads();
45280 result = (wxSizerItem *)new wxSizerItem();
45281 wxPyEndAllowThreads(__tstate);
45282 if (PyErr_Occurred()) SWIG_fail;
45283 }
45284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45285 return resultobj;
45286 fail:
45287 return NULL;
45288 }
45289
45290
45291 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45292 PyObject *resultobj = 0;
45293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45294 void *argp1 = 0 ;
45295 int res1 = 0 ;
45296 PyObject *swig_obj[1] ;
45297
45298 if (!args) SWIG_fail;
45299 swig_obj[0] = args;
45300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45301 if (!SWIG_IsOK(res1)) {
45302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45303 }
45304 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45305 {
45306 PyThreadState* __tstate = wxPyBeginAllowThreads();
45307 delete arg1;
45308
45309 wxPyEndAllowThreads(__tstate);
45310 if (PyErr_Occurred()) SWIG_fail;
45311 }
45312 resultobj = SWIG_Py_Void();
45313 return resultobj;
45314 fail:
45315 return NULL;
45316 }
45317
45318
45319 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45320 PyObject *resultobj = 0;
45321 wxWindow *arg1 = (wxWindow *) 0 ;
45322 int arg2 ;
45323 int arg3 ;
45324 int arg4 ;
45325 PyObject *arg5 = (PyObject *) NULL ;
45326 wxSizerItem *result = 0 ;
45327 void *argp1 = 0 ;
45328 int res1 = 0 ;
45329 int val2 ;
45330 int ecode2 = 0 ;
45331 int val3 ;
45332 int ecode3 = 0 ;
45333 int val4 ;
45334 int ecode4 = 0 ;
45335 PyObject * obj0 = 0 ;
45336 PyObject * obj1 = 0 ;
45337 PyObject * obj2 = 0 ;
45338 PyObject * obj3 = 0 ;
45339 PyObject * obj4 = 0 ;
45340 char * kwnames[] = {
45341 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45342 };
45343
45344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45346 if (!SWIG_IsOK(res1)) {
45347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45348 }
45349 arg1 = reinterpret_cast< wxWindow * >(argp1);
45350 ecode2 = SWIG_AsVal_int(obj1, &val2);
45351 if (!SWIG_IsOK(ecode2)) {
45352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45353 }
45354 arg2 = static_cast< int >(val2);
45355 ecode3 = SWIG_AsVal_int(obj2, &val3);
45356 if (!SWIG_IsOK(ecode3)) {
45357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45358 }
45359 arg3 = static_cast< int >(val3);
45360 ecode4 = SWIG_AsVal_int(obj3, &val4);
45361 if (!SWIG_IsOK(ecode4)) {
45362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45363 }
45364 arg4 = static_cast< int >(val4);
45365 if (obj4) {
45366 arg5 = obj4;
45367 }
45368 {
45369 PyThreadState* __tstate = wxPyBeginAllowThreads();
45370 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45371 wxPyEndAllowThreads(__tstate);
45372 if (PyErr_Occurred()) SWIG_fail;
45373 }
45374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45375 return resultobj;
45376 fail:
45377 return NULL;
45378 }
45379
45380
45381 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45382 PyObject *resultobj = 0;
45383 int arg1 ;
45384 int arg2 ;
45385 int arg3 ;
45386 int arg4 ;
45387 int arg5 ;
45388 PyObject *arg6 = (PyObject *) NULL ;
45389 wxSizerItem *result = 0 ;
45390 int val1 ;
45391 int ecode1 = 0 ;
45392 int val2 ;
45393 int ecode2 = 0 ;
45394 int val3 ;
45395 int ecode3 = 0 ;
45396 int val4 ;
45397 int ecode4 = 0 ;
45398 int val5 ;
45399 int ecode5 = 0 ;
45400 PyObject * obj0 = 0 ;
45401 PyObject * obj1 = 0 ;
45402 PyObject * obj2 = 0 ;
45403 PyObject * obj3 = 0 ;
45404 PyObject * obj4 = 0 ;
45405 PyObject * obj5 = 0 ;
45406 char * kwnames[] = {
45407 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45408 };
45409
45410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45411 ecode1 = SWIG_AsVal_int(obj0, &val1);
45412 if (!SWIG_IsOK(ecode1)) {
45413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45414 }
45415 arg1 = static_cast< int >(val1);
45416 ecode2 = SWIG_AsVal_int(obj1, &val2);
45417 if (!SWIG_IsOK(ecode2)) {
45418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45419 }
45420 arg2 = static_cast< int >(val2);
45421 ecode3 = SWIG_AsVal_int(obj2, &val3);
45422 if (!SWIG_IsOK(ecode3)) {
45423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45424 }
45425 arg3 = static_cast< int >(val3);
45426 ecode4 = SWIG_AsVal_int(obj3, &val4);
45427 if (!SWIG_IsOK(ecode4)) {
45428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45429 }
45430 arg4 = static_cast< int >(val4);
45431 ecode5 = SWIG_AsVal_int(obj4, &val5);
45432 if (!SWIG_IsOK(ecode5)) {
45433 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45434 }
45435 arg5 = static_cast< int >(val5);
45436 if (obj5) {
45437 arg6 = obj5;
45438 }
45439 {
45440 PyThreadState* __tstate = wxPyBeginAllowThreads();
45441 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45442 wxPyEndAllowThreads(__tstate);
45443 if (PyErr_Occurred()) SWIG_fail;
45444 }
45445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45446 return resultobj;
45447 fail:
45448 return NULL;
45449 }
45450
45451
45452 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45453 PyObject *resultobj = 0;
45454 wxSizer *arg1 = (wxSizer *) 0 ;
45455 int arg2 ;
45456 int arg3 ;
45457 int arg4 ;
45458 PyObject *arg5 = (PyObject *) NULL ;
45459 wxSizerItem *result = 0 ;
45460 int res1 = 0 ;
45461 int val2 ;
45462 int ecode2 = 0 ;
45463 int val3 ;
45464 int ecode3 = 0 ;
45465 int val4 ;
45466 int ecode4 = 0 ;
45467 PyObject * obj0 = 0 ;
45468 PyObject * obj1 = 0 ;
45469 PyObject * obj2 = 0 ;
45470 PyObject * obj3 = 0 ;
45471 PyObject * obj4 = 0 ;
45472 char * kwnames[] = {
45473 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45474 };
45475
45476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45477 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45478 if (!SWIG_IsOK(res1)) {
45479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45480 }
45481 ecode2 = SWIG_AsVal_int(obj1, &val2);
45482 if (!SWIG_IsOK(ecode2)) {
45483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45484 }
45485 arg2 = static_cast< int >(val2);
45486 ecode3 = SWIG_AsVal_int(obj2, &val3);
45487 if (!SWIG_IsOK(ecode3)) {
45488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45489 }
45490 arg3 = static_cast< int >(val3);
45491 ecode4 = SWIG_AsVal_int(obj3, &val4);
45492 if (!SWIG_IsOK(ecode4)) {
45493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45494 }
45495 arg4 = static_cast< int >(val4);
45496 if (obj4) {
45497 arg5 = obj4;
45498 }
45499 {
45500 PyThreadState* __tstate = wxPyBeginAllowThreads();
45501 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45502 wxPyEndAllowThreads(__tstate);
45503 if (PyErr_Occurred()) SWIG_fail;
45504 }
45505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45506 return resultobj;
45507 fail:
45508 return NULL;
45509 }
45510
45511
45512 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45513 PyObject *resultobj = 0;
45514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45515 void *argp1 = 0 ;
45516 int res1 = 0 ;
45517 PyObject *swig_obj[1] ;
45518
45519 if (!args) SWIG_fail;
45520 swig_obj[0] = args;
45521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45522 if (!SWIG_IsOK(res1)) {
45523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45524 }
45525 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45526 {
45527 PyThreadState* __tstate = wxPyBeginAllowThreads();
45528 (arg1)->DeleteWindows();
45529 wxPyEndAllowThreads(__tstate);
45530 if (PyErr_Occurred()) SWIG_fail;
45531 }
45532 resultobj = SWIG_Py_Void();
45533 return resultobj;
45534 fail:
45535 return NULL;
45536 }
45537
45538
45539 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45540 PyObject *resultobj = 0;
45541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45542 void *argp1 = 0 ;
45543 int res1 = 0 ;
45544 PyObject *swig_obj[1] ;
45545
45546 if (!args) SWIG_fail;
45547 swig_obj[0] = args;
45548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45549 if (!SWIG_IsOK(res1)) {
45550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45551 }
45552 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45553 {
45554 PyThreadState* __tstate = wxPyBeginAllowThreads();
45555 (arg1)->DetachSizer();
45556 wxPyEndAllowThreads(__tstate);
45557 if (PyErr_Occurred()) SWIG_fail;
45558 }
45559 resultobj = SWIG_Py_Void();
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45567 PyObject *resultobj = 0;
45568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45569 wxSize result;
45570 void *argp1 = 0 ;
45571 int res1 = 0 ;
45572 PyObject *swig_obj[1] ;
45573
45574 if (!args) SWIG_fail;
45575 swig_obj[0] = args;
45576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45577 if (!SWIG_IsOK(res1)) {
45578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45579 }
45580 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45581 {
45582 PyThreadState* __tstate = wxPyBeginAllowThreads();
45583 result = (arg1)->GetSize();
45584 wxPyEndAllowThreads(__tstate);
45585 if (PyErr_Occurred()) SWIG_fail;
45586 }
45587 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45588 return resultobj;
45589 fail:
45590 return NULL;
45591 }
45592
45593
45594 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45595 PyObject *resultobj = 0;
45596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45597 wxSize result;
45598 void *argp1 = 0 ;
45599 int res1 = 0 ;
45600 PyObject *swig_obj[1] ;
45601
45602 if (!args) SWIG_fail;
45603 swig_obj[0] = args;
45604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45605 if (!SWIG_IsOK(res1)) {
45606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45607 }
45608 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45609 {
45610 PyThreadState* __tstate = wxPyBeginAllowThreads();
45611 result = (arg1)->CalcMin();
45612 wxPyEndAllowThreads(__tstate);
45613 if (PyErr_Occurred()) SWIG_fail;
45614 }
45615 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45616 return resultobj;
45617 fail:
45618 return NULL;
45619 }
45620
45621
45622 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45623 PyObject *resultobj = 0;
45624 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45625 wxPoint *arg2 = 0 ;
45626 wxSize *arg3 = 0 ;
45627 void *argp1 = 0 ;
45628 int res1 = 0 ;
45629 wxPoint temp2 ;
45630 wxSize temp3 ;
45631 PyObject * obj0 = 0 ;
45632 PyObject * obj1 = 0 ;
45633 PyObject * obj2 = 0 ;
45634 char * kwnames[] = {
45635 (char *) "self",(char *) "pos",(char *) "size", NULL
45636 };
45637
45638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45640 if (!SWIG_IsOK(res1)) {
45641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45642 }
45643 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45644 {
45645 arg2 = &temp2;
45646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45647 }
45648 {
45649 arg3 = &temp3;
45650 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45651 }
45652 {
45653 PyThreadState* __tstate = wxPyBeginAllowThreads();
45654 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45655 wxPyEndAllowThreads(__tstate);
45656 if (PyErr_Occurred()) SWIG_fail;
45657 }
45658 resultobj = SWIG_Py_Void();
45659 return resultobj;
45660 fail:
45661 return NULL;
45662 }
45663
45664
45665 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45666 PyObject *resultobj = 0;
45667 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45668 wxSize result;
45669 void *argp1 = 0 ;
45670 int res1 = 0 ;
45671 PyObject *swig_obj[1] ;
45672
45673 if (!args) SWIG_fail;
45674 swig_obj[0] = args;
45675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45678 }
45679 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45680 {
45681 PyThreadState* __tstate = wxPyBeginAllowThreads();
45682 result = (arg1)->GetMinSize();
45683 wxPyEndAllowThreads(__tstate);
45684 if (PyErr_Occurred()) SWIG_fail;
45685 }
45686 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45687 return resultobj;
45688 fail:
45689 return NULL;
45690 }
45691
45692
45693 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45694 PyObject *resultobj = 0;
45695 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45696 wxSize result;
45697 void *argp1 = 0 ;
45698 int res1 = 0 ;
45699 PyObject *swig_obj[1] ;
45700
45701 if (!args) SWIG_fail;
45702 swig_obj[0] = args;
45703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45704 if (!SWIG_IsOK(res1)) {
45705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45706 }
45707 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45708 {
45709 PyThreadState* __tstate = wxPyBeginAllowThreads();
45710 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45711 wxPyEndAllowThreads(__tstate);
45712 if (PyErr_Occurred()) SWIG_fail;
45713 }
45714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45715 return resultobj;
45716 fail:
45717 return NULL;
45718 }
45719
45720
45721 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45722 PyObject *resultobj = 0;
45723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45724 int arg2 ;
45725 int arg3 ;
45726 void *argp1 = 0 ;
45727 int res1 = 0 ;
45728 int val2 ;
45729 int ecode2 = 0 ;
45730 int val3 ;
45731 int ecode3 = 0 ;
45732 PyObject * obj0 = 0 ;
45733 PyObject * obj1 = 0 ;
45734 PyObject * obj2 = 0 ;
45735 char * kwnames[] = {
45736 (char *) "self",(char *) "x",(char *) "y", NULL
45737 };
45738
45739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45741 if (!SWIG_IsOK(res1)) {
45742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45743 }
45744 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45745 ecode2 = SWIG_AsVal_int(obj1, &val2);
45746 if (!SWIG_IsOK(ecode2)) {
45747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45748 }
45749 arg2 = static_cast< int >(val2);
45750 ecode3 = SWIG_AsVal_int(obj2, &val3);
45751 if (!SWIG_IsOK(ecode3)) {
45752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45753 }
45754 arg3 = static_cast< int >(val3);
45755 {
45756 PyThreadState* __tstate = wxPyBeginAllowThreads();
45757 (arg1)->SetInitSize(arg2,arg3);
45758 wxPyEndAllowThreads(__tstate);
45759 if (PyErr_Occurred()) SWIG_fail;
45760 }
45761 resultobj = SWIG_Py_Void();
45762 return resultobj;
45763 fail:
45764 return NULL;
45765 }
45766
45767
45768 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45769 PyObject *resultobj = 0;
45770 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45771 int arg2 ;
45772 int arg3 ;
45773 void *argp1 = 0 ;
45774 int res1 = 0 ;
45775 int val2 ;
45776 int ecode2 = 0 ;
45777 int val3 ;
45778 int ecode3 = 0 ;
45779 PyObject * obj0 = 0 ;
45780 PyObject * obj1 = 0 ;
45781 PyObject * obj2 = 0 ;
45782 char * kwnames[] = {
45783 (char *) "self",(char *) "width",(char *) "height", NULL
45784 };
45785
45786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45788 if (!SWIG_IsOK(res1)) {
45789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45790 }
45791 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45792 ecode2 = SWIG_AsVal_int(obj1, &val2);
45793 if (!SWIG_IsOK(ecode2)) {
45794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45795 }
45796 arg2 = static_cast< int >(val2);
45797 ecode3 = SWIG_AsVal_int(obj2, &val3);
45798 if (!SWIG_IsOK(ecode3)) {
45799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45800 }
45801 arg3 = static_cast< int >(val3);
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 (arg1)->SetRatio(arg2,arg3);
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 resultobj = SWIG_Py_Void();
45809 return resultobj;
45810 fail:
45811 return NULL;
45812 }
45813
45814
45815 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45816 PyObject *resultobj = 0;
45817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45818 wxSize *arg2 = 0 ;
45819 void *argp1 = 0 ;
45820 int res1 = 0 ;
45821 wxSize temp2 ;
45822 PyObject * obj0 = 0 ;
45823 PyObject * obj1 = 0 ;
45824 char * kwnames[] = {
45825 (char *) "self",(char *) "size", NULL
45826 };
45827
45828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45830 if (!SWIG_IsOK(res1)) {
45831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45832 }
45833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45834 {
45835 arg2 = &temp2;
45836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45837 }
45838 {
45839 PyThreadState* __tstate = wxPyBeginAllowThreads();
45840 (arg1)->SetRatio((wxSize const &)*arg2);
45841 wxPyEndAllowThreads(__tstate);
45842 if (PyErr_Occurred()) SWIG_fail;
45843 }
45844 resultobj = SWIG_Py_Void();
45845 return resultobj;
45846 fail:
45847 return NULL;
45848 }
45849
45850
45851 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45852 PyObject *resultobj = 0;
45853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45854 float arg2 ;
45855 void *argp1 = 0 ;
45856 int res1 = 0 ;
45857 float val2 ;
45858 int ecode2 = 0 ;
45859 PyObject * obj0 = 0 ;
45860 PyObject * obj1 = 0 ;
45861 char * kwnames[] = {
45862 (char *) "self",(char *) "ratio", NULL
45863 };
45864
45865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45867 if (!SWIG_IsOK(res1)) {
45868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45869 }
45870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45871 ecode2 = SWIG_AsVal_float(obj1, &val2);
45872 if (!SWIG_IsOK(ecode2)) {
45873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45874 }
45875 arg2 = static_cast< float >(val2);
45876 {
45877 PyThreadState* __tstate = wxPyBeginAllowThreads();
45878 (arg1)->SetRatio(arg2);
45879 wxPyEndAllowThreads(__tstate);
45880 if (PyErr_Occurred()) SWIG_fail;
45881 }
45882 resultobj = SWIG_Py_Void();
45883 return resultobj;
45884 fail:
45885 return NULL;
45886 }
45887
45888
45889 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45890 PyObject *resultobj = 0;
45891 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45892 float result;
45893 void *argp1 = 0 ;
45894 int res1 = 0 ;
45895 PyObject *swig_obj[1] ;
45896
45897 if (!args) SWIG_fail;
45898 swig_obj[0] = args;
45899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45900 if (!SWIG_IsOK(res1)) {
45901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45902 }
45903 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45904 {
45905 PyThreadState* __tstate = wxPyBeginAllowThreads();
45906 result = (float)(arg1)->GetRatio();
45907 wxPyEndAllowThreads(__tstate);
45908 if (PyErr_Occurred()) SWIG_fail;
45909 }
45910 resultobj = SWIG_From_float(static_cast< float >(result));
45911 return resultobj;
45912 fail:
45913 return NULL;
45914 }
45915
45916
45917 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45918 PyObject *resultobj = 0;
45919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45920 wxRect result;
45921 void *argp1 = 0 ;
45922 int res1 = 0 ;
45923 PyObject *swig_obj[1] ;
45924
45925 if (!args) SWIG_fail;
45926 swig_obj[0] = args;
45927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45928 if (!SWIG_IsOK(res1)) {
45929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45930 }
45931 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45932 {
45933 PyThreadState* __tstate = wxPyBeginAllowThreads();
45934 result = (arg1)->GetRect();
45935 wxPyEndAllowThreads(__tstate);
45936 if (PyErr_Occurred()) SWIG_fail;
45937 }
45938 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45939 return resultobj;
45940 fail:
45941 return NULL;
45942 }
45943
45944
45945 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45946 PyObject *resultobj = 0;
45947 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45948 bool result;
45949 void *argp1 = 0 ;
45950 int res1 = 0 ;
45951 PyObject *swig_obj[1] ;
45952
45953 if (!args) SWIG_fail;
45954 swig_obj[0] = args;
45955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45956 if (!SWIG_IsOK(res1)) {
45957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45958 }
45959 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45960 {
45961 PyThreadState* __tstate = wxPyBeginAllowThreads();
45962 result = (bool)(arg1)->IsWindow();
45963 wxPyEndAllowThreads(__tstate);
45964 if (PyErr_Occurred()) SWIG_fail;
45965 }
45966 {
45967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45968 }
45969 return resultobj;
45970 fail:
45971 return NULL;
45972 }
45973
45974
45975 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45976 PyObject *resultobj = 0;
45977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45978 bool result;
45979 void *argp1 = 0 ;
45980 int res1 = 0 ;
45981 PyObject *swig_obj[1] ;
45982
45983 if (!args) SWIG_fail;
45984 swig_obj[0] = args;
45985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45986 if (!SWIG_IsOK(res1)) {
45987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45988 }
45989 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45990 {
45991 PyThreadState* __tstate = wxPyBeginAllowThreads();
45992 result = (bool)(arg1)->IsSizer();
45993 wxPyEndAllowThreads(__tstate);
45994 if (PyErr_Occurred()) SWIG_fail;
45995 }
45996 {
45997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45998 }
45999 return resultobj;
46000 fail:
46001 return NULL;
46002 }
46003
46004
46005 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46006 PyObject *resultobj = 0;
46007 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46008 bool result;
46009 void *argp1 = 0 ;
46010 int res1 = 0 ;
46011 PyObject *swig_obj[1] ;
46012
46013 if (!args) SWIG_fail;
46014 swig_obj[0] = args;
46015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46016 if (!SWIG_IsOK(res1)) {
46017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46018 }
46019 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46020 {
46021 PyThreadState* __tstate = wxPyBeginAllowThreads();
46022 result = (bool)(arg1)->IsSpacer();
46023 wxPyEndAllowThreads(__tstate);
46024 if (PyErr_Occurred()) SWIG_fail;
46025 }
46026 {
46027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46028 }
46029 return resultobj;
46030 fail:
46031 return NULL;
46032 }
46033
46034
46035 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46036 PyObject *resultobj = 0;
46037 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46038 int arg2 ;
46039 void *argp1 = 0 ;
46040 int res1 = 0 ;
46041 int val2 ;
46042 int ecode2 = 0 ;
46043 PyObject * obj0 = 0 ;
46044 PyObject * obj1 = 0 ;
46045 char * kwnames[] = {
46046 (char *) "self",(char *) "proportion", NULL
46047 };
46048
46049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46051 if (!SWIG_IsOK(res1)) {
46052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46053 }
46054 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46055 ecode2 = SWIG_AsVal_int(obj1, &val2);
46056 if (!SWIG_IsOK(ecode2)) {
46057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46058 }
46059 arg2 = static_cast< int >(val2);
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 (arg1)->SetProportion(arg2);
46063 wxPyEndAllowThreads(__tstate);
46064 if (PyErr_Occurred()) SWIG_fail;
46065 }
46066 resultobj = SWIG_Py_Void();
46067 return resultobj;
46068 fail:
46069 return NULL;
46070 }
46071
46072
46073 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46074 PyObject *resultobj = 0;
46075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46076 int result;
46077 void *argp1 = 0 ;
46078 int res1 = 0 ;
46079 PyObject *swig_obj[1] ;
46080
46081 if (!args) SWIG_fail;
46082 swig_obj[0] = args;
46083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46084 if (!SWIG_IsOK(res1)) {
46085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46086 }
46087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46088 {
46089 PyThreadState* __tstate = wxPyBeginAllowThreads();
46090 result = (int)(arg1)->GetProportion();
46091 wxPyEndAllowThreads(__tstate);
46092 if (PyErr_Occurred()) SWIG_fail;
46093 }
46094 resultobj = SWIG_From_int(static_cast< int >(result));
46095 return resultobj;
46096 fail:
46097 return NULL;
46098 }
46099
46100
46101 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46102 PyObject *resultobj = 0;
46103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46104 int arg2 ;
46105 void *argp1 = 0 ;
46106 int res1 = 0 ;
46107 int val2 ;
46108 int ecode2 = 0 ;
46109 PyObject * obj0 = 0 ;
46110 PyObject * obj1 = 0 ;
46111 char * kwnames[] = {
46112 (char *) "self",(char *) "flag", NULL
46113 };
46114
46115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46117 if (!SWIG_IsOK(res1)) {
46118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46119 }
46120 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46121 ecode2 = SWIG_AsVal_int(obj1, &val2);
46122 if (!SWIG_IsOK(ecode2)) {
46123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46124 }
46125 arg2 = static_cast< int >(val2);
46126 {
46127 PyThreadState* __tstate = wxPyBeginAllowThreads();
46128 (arg1)->SetFlag(arg2);
46129 wxPyEndAllowThreads(__tstate);
46130 if (PyErr_Occurred()) SWIG_fail;
46131 }
46132 resultobj = SWIG_Py_Void();
46133 return resultobj;
46134 fail:
46135 return NULL;
46136 }
46137
46138
46139 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46140 PyObject *resultobj = 0;
46141 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46142 int result;
46143 void *argp1 = 0 ;
46144 int res1 = 0 ;
46145 PyObject *swig_obj[1] ;
46146
46147 if (!args) SWIG_fail;
46148 swig_obj[0] = args;
46149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46150 if (!SWIG_IsOK(res1)) {
46151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46152 }
46153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46154 {
46155 PyThreadState* __tstate = wxPyBeginAllowThreads();
46156 result = (int)(arg1)->GetFlag();
46157 wxPyEndAllowThreads(__tstate);
46158 if (PyErr_Occurred()) SWIG_fail;
46159 }
46160 resultobj = SWIG_From_int(static_cast< int >(result));
46161 return resultobj;
46162 fail:
46163 return NULL;
46164 }
46165
46166
46167 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46168 PyObject *resultobj = 0;
46169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46170 int arg2 ;
46171 void *argp1 = 0 ;
46172 int res1 = 0 ;
46173 int val2 ;
46174 int ecode2 = 0 ;
46175 PyObject * obj0 = 0 ;
46176 PyObject * obj1 = 0 ;
46177 char * kwnames[] = {
46178 (char *) "self",(char *) "border", NULL
46179 };
46180
46181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46183 if (!SWIG_IsOK(res1)) {
46184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46185 }
46186 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46187 ecode2 = SWIG_AsVal_int(obj1, &val2);
46188 if (!SWIG_IsOK(ecode2)) {
46189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46190 }
46191 arg2 = static_cast< int >(val2);
46192 {
46193 PyThreadState* __tstate = wxPyBeginAllowThreads();
46194 (arg1)->SetBorder(arg2);
46195 wxPyEndAllowThreads(__tstate);
46196 if (PyErr_Occurred()) SWIG_fail;
46197 }
46198 resultobj = SWIG_Py_Void();
46199 return resultobj;
46200 fail:
46201 return NULL;
46202 }
46203
46204
46205 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46206 PyObject *resultobj = 0;
46207 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46208 int result;
46209 void *argp1 = 0 ;
46210 int res1 = 0 ;
46211 PyObject *swig_obj[1] ;
46212
46213 if (!args) SWIG_fail;
46214 swig_obj[0] = args;
46215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46216 if (!SWIG_IsOK(res1)) {
46217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46218 }
46219 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46220 {
46221 PyThreadState* __tstate = wxPyBeginAllowThreads();
46222 result = (int)(arg1)->GetBorder();
46223 wxPyEndAllowThreads(__tstate);
46224 if (PyErr_Occurred()) SWIG_fail;
46225 }
46226 resultobj = SWIG_From_int(static_cast< int >(result));
46227 return resultobj;
46228 fail:
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46234 PyObject *resultobj = 0;
46235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46236 wxWindow *result = 0 ;
46237 void *argp1 = 0 ;
46238 int res1 = 0 ;
46239 PyObject *swig_obj[1] ;
46240
46241 if (!args) SWIG_fail;
46242 swig_obj[0] = args;
46243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46244 if (!SWIG_IsOK(res1)) {
46245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46246 }
46247 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46248 {
46249 PyThreadState* __tstate = wxPyBeginAllowThreads();
46250 result = (wxWindow *)(arg1)->GetWindow();
46251 wxPyEndAllowThreads(__tstate);
46252 if (PyErr_Occurred()) SWIG_fail;
46253 }
46254 {
46255 resultobj = wxPyMake_wxObject(result, 0);
46256 }
46257 return resultobj;
46258 fail:
46259 return NULL;
46260 }
46261
46262
46263 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46264 PyObject *resultobj = 0;
46265 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46266 wxWindow *arg2 = (wxWindow *) 0 ;
46267 void *argp1 = 0 ;
46268 int res1 = 0 ;
46269 void *argp2 = 0 ;
46270 int res2 = 0 ;
46271 PyObject * obj0 = 0 ;
46272 PyObject * obj1 = 0 ;
46273 char * kwnames[] = {
46274 (char *) "self",(char *) "window", NULL
46275 };
46276
46277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46279 if (!SWIG_IsOK(res1)) {
46280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46281 }
46282 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46284 if (!SWIG_IsOK(res2)) {
46285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46286 }
46287 arg2 = reinterpret_cast< wxWindow * >(argp2);
46288 {
46289 PyThreadState* __tstate = wxPyBeginAllowThreads();
46290 (arg1)->SetWindow(arg2);
46291 wxPyEndAllowThreads(__tstate);
46292 if (PyErr_Occurred()) SWIG_fail;
46293 }
46294 resultobj = SWIG_Py_Void();
46295 return resultobj;
46296 fail:
46297 return NULL;
46298 }
46299
46300
46301 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46302 PyObject *resultobj = 0;
46303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46304 wxSizer *result = 0 ;
46305 void *argp1 = 0 ;
46306 int res1 = 0 ;
46307 PyObject *swig_obj[1] ;
46308
46309 if (!args) SWIG_fail;
46310 swig_obj[0] = args;
46311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46312 if (!SWIG_IsOK(res1)) {
46313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46314 }
46315 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46316 {
46317 PyThreadState* __tstate = wxPyBeginAllowThreads();
46318 result = (wxSizer *)(arg1)->GetSizer();
46319 wxPyEndAllowThreads(__tstate);
46320 if (PyErr_Occurred()) SWIG_fail;
46321 }
46322 {
46323 resultobj = wxPyMake_wxObject(result, (bool)0);
46324 }
46325 return resultobj;
46326 fail:
46327 return NULL;
46328 }
46329
46330
46331 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46332 PyObject *resultobj = 0;
46333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46334 wxSizer *arg2 = (wxSizer *) 0 ;
46335 void *argp1 = 0 ;
46336 int res1 = 0 ;
46337 int res2 = 0 ;
46338 PyObject * obj0 = 0 ;
46339 PyObject * obj1 = 0 ;
46340 char * kwnames[] = {
46341 (char *) "self",(char *) "sizer", NULL
46342 };
46343
46344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46346 if (!SWIG_IsOK(res1)) {
46347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46348 }
46349 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46350 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46351 if (!SWIG_IsOK(res2)) {
46352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46353 }
46354 {
46355 PyThreadState* __tstate = wxPyBeginAllowThreads();
46356 (arg1)->SetSizer(arg2);
46357 wxPyEndAllowThreads(__tstate);
46358 if (PyErr_Occurred()) SWIG_fail;
46359 }
46360 resultobj = SWIG_Py_Void();
46361 return resultobj;
46362 fail:
46363 return NULL;
46364 }
46365
46366
46367 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46368 PyObject *resultobj = 0;
46369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46370 wxSize *result = 0 ;
46371 void *argp1 = 0 ;
46372 int res1 = 0 ;
46373 PyObject *swig_obj[1] ;
46374
46375 if (!args) SWIG_fail;
46376 swig_obj[0] = args;
46377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46378 if (!SWIG_IsOK(res1)) {
46379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46380 }
46381 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46382 {
46383 PyThreadState* __tstate = wxPyBeginAllowThreads();
46384 {
46385 wxSize const &_result_ref = (arg1)->GetSpacer();
46386 result = (wxSize *) &_result_ref;
46387 }
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46399 PyObject *resultobj = 0;
46400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46401 wxSize *arg2 = 0 ;
46402 void *argp1 = 0 ;
46403 int res1 = 0 ;
46404 wxSize temp2 ;
46405 PyObject * obj0 = 0 ;
46406 PyObject * obj1 = 0 ;
46407 char * kwnames[] = {
46408 (char *) "self",(char *) "size", NULL
46409 };
46410
46411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46413 if (!SWIG_IsOK(res1)) {
46414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46415 }
46416 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46417 {
46418 arg2 = &temp2;
46419 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46420 }
46421 {
46422 PyThreadState* __tstate = wxPyBeginAllowThreads();
46423 (arg1)->SetSpacer((wxSize const &)*arg2);
46424 wxPyEndAllowThreads(__tstate);
46425 if (PyErr_Occurred()) SWIG_fail;
46426 }
46427 resultobj = SWIG_Py_Void();
46428 return resultobj;
46429 fail:
46430 return NULL;
46431 }
46432
46433
46434 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46435 PyObject *resultobj = 0;
46436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46437 bool arg2 ;
46438 void *argp1 = 0 ;
46439 int res1 = 0 ;
46440 bool val2 ;
46441 int ecode2 = 0 ;
46442 PyObject * obj0 = 0 ;
46443 PyObject * obj1 = 0 ;
46444 char * kwnames[] = {
46445 (char *) "self",(char *) "show", NULL
46446 };
46447
46448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46450 if (!SWIG_IsOK(res1)) {
46451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46452 }
46453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46455 if (!SWIG_IsOK(ecode2)) {
46456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46457 }
46458 arg2 = static_cast< bool >(val2);
46459 {
46460 PyThreadState* __tstate = wxPyBeginAllowThreads();
46461 (arg1)->Show(arg2);
46462 wxPyEndAllowThreads(__tstate);
46463 if (PyErr_Occurred()) SWIG_fail;
46464 }
46465 resultobj = SWIG_Py_Void();
46466 return resultobj;
46467 fail:
46468 return NULL;
46469 }
46470
46471
46472 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46473 PyObject *resultobj = 0;
46474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46475 bool result;
46476 void *argp1 = 0 ;
46477 int res1 = 0 ;
46478 PyObject *swig_obj[1] ;
46479
46480 if (!args) SWIG_fail;
46481 swig_obj[0] = args;
46482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46483 if (!SWIG_IsOK(res1)) {
46484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46485 }
46486 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46487 {
46488 PyThreadState* __tstate = wxPyBeginAllowThreads();
46489 result = (bool)(arg1)->IsShown();
46490 wxPyEndAllowThreads(__tstate);
46491 if (PyErr_Occurred()) SWIG_fail;
46492 }
46493 {
46494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46495 }
46496 return resultobj;
46497 fail:
46498 return NULL;
46499 }
46500
46501
46502 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46503 PyObject *resultobj = 0;
46504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46505 wxPoint result;
46506 void *argp1 = 0 ;
46507 int res1 = 0 ;
46508 PyObject *swig_obj[1] ;
46509
46510 if (!args) SWIG_fail;
46511 swig_obj[0] = args;
46512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46513 if (!SWIG_IsOK(res1)) {
46514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46515 }
46516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46517 {
46518 PyThreadState* __tstate = wxPyBeginAllowThreads();
46519 result = (arg1)->GetPosition();
46520 wxPyEndAllowThreads(__tstate);
46521 if (PyErr_Occurred()) SWIG_fail;
46522 }
46523 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46524 return resultobj;
46525 fail:
46526 return NULL;
46527 }
46528
46529
46530 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46531 PyObject *resultobj = 0;
46532 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46533 PyObject *result = 0 ;
46534 void *argp1 = 0 ;
46535 int res1 = 0 ;
46536 PyObject *swig_obj[1] ;
46537
46538 if (!args) SWIG_fail;
46539 swig_obj[0] = args;
46540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46541 if (!SWIG_IsOK(res1)) {
46542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46543 }
46544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46545 {
46546 PyThreadState* __tstate = wxPyBeginAllowThreads();
46547 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46548 wxPyEndAllowThreads(__tstate);
46549 if (PyErr_Occurred()) SWIG_fail;
46550 }
46551 resultobj = result;
46552 return resultobj;
46553 fail:
46554 return NULL;
46555 }
46556
46557
46558 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46559 PyObject *resultobj = 0;
46560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46561 PyObject *arg2 = (PyObject *) 0 ;
46562 void *argp1 = 0 ;
46563 int res1 = 0 ;
46564 PyObject * obj0 = 0 ;
46565 PyObject * obj1 = 0 ;
46566 char * kwnames[] = {
46567 (char *) "self",(char *) "userData", NULL
46568 };
46569
46570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46572 if (!SWIG_IsOK(res1)) {
46573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46574 }
46575 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46576 arg2 = obj1;
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 wxSizerItem_SetUserData(arg1,arg2);
46580 wxPyEndAllowThreads(__tstate);
46581 if (PyErr_Occurred()) SWIG_fail;
46582 }
46583 resultobj = SWIG_Py_Void();
46584 return resultobj;
46585 fail:
46586 return NULL;
46587 }
46588
46589
46590 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46591 PyObject *obj;
46592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46593 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46594 return SWIG_Py_Void();
46595 }
46596
46597 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46598 return SWIG_Python_InitShadowInstance(args);
46599 }
46600
46601 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46602 PyObject *resultobj = 0;
46603 wxSizer *arg1 = (wxSizer *) 0 ;
46604 void *argp1 = 0 ;
46605 int res1 = 0 ;
46606 PyObject *swig_obj[1] ;
46607
46608 if (!args) SWIG_fail;
46609 swig_obj[0] = args;
46610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46611 if (!SWIG_IsOK(res1)) {
46612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46613 }
46614 arg1 = reinterpret_cast< wxSizer * >(argp1);
46615 {
46616 PyThreadState* __tstate = wxPyBeginAllowThreads();
46617 delete arg1;
46618
46619 wxPyEndAllowThreads(__tstate);
46620 if (PyErr_Occurred()) SWIG_fail;
46621 }
46622 resultobj = SWIG_Py_Void();
46623 return resultobj;
46624 fail:
46625 return NULL;
46626 }
46627
46628
46629 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46630 PyObject *resultobj = 0;
46631 wxSizer *arg1 = (wxSizer *) 0 ;
46632 PyObject *arg2 = (PyObject *) 0 ;
46633 void *argp1 = 0 ;
46634 int res1 = 0 ;
46635 PyObject * obj0 = 0 ;
46636 PyObject * obj1 = 0 ;
46637 char * kwnames[] = {
46638 (char *) "self",(char *) "_self", NULL
46639 };
46640
46641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46643 if (!SWIG_IsOK(res1)) {
46644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46645 }
46646 arg1 = reinterpret_cast< wxSizer * >(argp1);
46647 arg2 = obj1;
46648 {
46649 PyThreadState* __tstate = wxPyBeginAllowThreads();
46650 wxSizer__setOORInfo(arg1,arg2);
46651 wxPyEndAllowThreads(__tstate);
46652 if (PyErr_Occurred()) SWIG_fail;
46653 }
46654 resultobj = SWIG_Py_Void();
46655 return resultobj;
46656 fail:
46657 return NULL;
46658 }
46659
46660
46661 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46662 PyObject *resultobj = 0;
46663 wxSizer *arg1 = (wxSizer *) 0 ;
46664 PyObject *arg2 = (PyObject *) 0 ;
46665 int arg3 = (int) 0 ;
46666 int arg4 = (int) 0 ;
46667 int arg5 = (int) 0 ;
46668 PyObject *arg6 = (PyObject *) NULL ;
46669 wxSizerItem *result = 0 ;
46670 void *argp1 = 0 ;
46671 int res1 = 0 ;
46672 int val3 ;
46673 int ecode3 = 0 ;
46674 int val4 ;
46675 int ecode4 = 0 ;
46676 int val5 ;
46677 int ecode5 = 0 ;
46678 PyObject * obj0 = 0 ;
46679 PyObject * obj1 = 0 ;
46680 PyObject * obj2 = 0 ;
46681 PyObject * obj3 = 0 ;
46682 PyObject * obj4 = 0 ;
46683 PyObject * obj5 = 0 ;
46684 char * kwnames[] = {
46685 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46686 };
46687
46688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46690 if (!SWIG_IsOK(res1)) {
46691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46692 }
46693 arg1 = reinterpret_cast< wxSizer * >(argp1);
46694 arg2 = obj1;
46695 if (obj2) {
46696 ecode3 = SWIG_AsVal_int(obj2, &val3);
46697 if (!SWIG_IsOK(ecode3)) {
46698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46699 }
46700 arg3 = static_cast< int >(val3);
46701 }
46702 if (obj3) {
46703 ecode4 = SWIG_AsVal_int(obj3, &val4);
46704 if (!SWIG_IsOK(ecode4)) {
46705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46706 }
46707 arg4 = static_cast< int >(val4);
46708 }
46709 if (obj4) {
46710 ecode5 = SWIG_AsVal_int(obj4, &val5);
46711 if (!SWIG_IsOK(ecode5)) {
46712 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46713 }
46714 arg5 = static_cast< int >(val5);
46715 }
46716 if (obj5) {
46717 arg6 = obj5;
46718 }
46719 {
46720 PyThreadState* __tstate = wxPyBeginAllowThreads();
46721 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46722 wxPyEndAllowThreads(__tstate);
46723 if (PyErr_Occurred()) SWIG_fail;
46724 }
46725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46733 PyObject *resultobj = 0;
46734 wxSizer *arg1 = (wxSizer *) 0 ;
46735 int arg2 ;
46736 PyObject *arg3 = (PyObject *) 0 ;
46737 int arg4 = (int) 0 ;
46738 int arg5 = (int) 0 ;
46739 int arg6 = (int) 0 ;
46740 PyObject *arg7 = (PyObject *) NULL ;
46741 wxSizerItem *result = 0 ;
46742 void *argp1 = 0 ;
46743 int res1 = 0 ;
46744 int val2 ;
46745 int ecode2 = 0 ;
46746 int val4 ;
46747 int ecode4 = 0 ;
46748 int val5 ;
46749 int ecode5 = 0 ;
46750 int val6 ;
46751 int ecode6 = 0 ;
46752 PyObject * obj0 = 0 ;
46753 PyObject * obj1 = 0 ;
46754 PyObject * obj2 = 0 ;
46755 PyObject * obj3 = 0 ;
46756 PyObject * obj4 = 0 ;
46757 PyObject * obj5 = 0 ;
46758 PyObject * obj6 = 0 ;
46759 char * kwnames[] = {
46760 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46761 };
46762
46763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46765 if (!SWIG_IsOK(res1)) {
46766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46767 }
46768 arg1 = reinterpret_cast< wxSizer * >(argp1);
46769 ecode2 = SWIG_AsVal_int(obj1, &val2);
46770 if (!SWIG_IsOK(ecode2)) {
46771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46772 }
46773 arg2 = static_cast< int >(val2);
46774 arg3 = obj2;
46775 if (obj3) {
46776 ecode4 = SWIG_AsVal_int(obj3, &val4);
46777 if (!SWIG_IsOK(ecode4)) {
46778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46779 }
46780 arg4 = static_cast< int >(val4);
46781 }
46782 if (obj4) {
46783 ecode5 = SWIG_AsVal_int(obj4, &val5);
46784 if (!SWIG_IsOK(ecode5)) {
46785 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46786 }
46787 arg5 = static_cast< int >(val5);
46788 }
46789 if (obj5) {
46790 ecode6 = SWIG_AsVal_int(obj5, &val6);
46791 if (!SWIG_IsOK(ecode6)) {
46792 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46793 }
46794 arg6 = static_cast< int >(val6);
46795 }
46796 if (obj6) {
46797 arg7 = obj6;
46798 }
46799 {
46800 PyThreadState* __tstate = wxPyBeginAllowThreads();
46801 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46802 wxPyEndAllowThreads(__tstate);
46803 if (PyErr_Occurred()) SWIG_fail;
46804 }
46805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46806 return resultobj;
46807 fail:
46808 return NULL;
46809 }
46810
46811
46812 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46813 PyObject *resultobj = 0;
46814 wxSizer *arg1 = (wxSizer *) 0 ;
46815 PyObject *arg2 = (PyObject *) 0 ;
46816 int arg3 = (int) 0 ;
46817 int arg4 = (int) 0 ;
46818 int arg5 = (int) 0 ;
46819 PyObject *arg6 = (PyObject *) NULL ;
46820 wxSizerItem *result = 0 ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 int val3 ;
46824 int ecode3 = 0 ;
46825 int val4 ;
46826 int ecode4 = 0 ;
46827 int val5 ;
46828 int ecode5 = 0 ;
46829 PyObject * obj0 = 0 ;
46830 PyObject * obj1 = 0 ;
46831 PyObject * obj2 = 0 ;
46832 PyObject * obj3 = 0 ;
46833 PyObject * obj4 = 0 ;
46834 PyObject * obj5 = 0 ;
46835 char * kwnames[] = {
46836 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46837 };
46838
46839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46843 }
46844 arg1 = reinterpret_cast< wxSizer * >(argp1);
46845 arg2 = obj1;
46846 if (obj2) {
46847 ecode3 = SWIG_AsVal_int(obj2, &val3);
46848 if (!SWIG_IsOK(ecode3)) {
46849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46850 }
46851 arg3 = static_cast< int >(val3);
46852 }
46853 if (obj3) {
46854 ecode4 = SWIG_AsVal_int(obj3, &val4);
46855 if (!SWIG_IsOK(ecode4)) {
46856 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46857 }
46858 arg4 = static_cast< int >(val4);
46859 }
46860 if (obj4) {
46861 ecode5 = SWIG_AsVal_int(obj4, &val5);
46862 if (!SWIG_IsOK(ecode5)) {
46863 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46864 }
46865 arg5 = static_cast< int >(val5);
46866 }
46867 if (obj5) {
46868 arg6 = obj5;
46869 }
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46877 return resultobj;
46878 fail:
46879 return NULL;
46880 }
46881
46882
46883 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46884 PyObject *resultobj = 0;
46885 wxSizer *arg1 = (wxSizer *) 0 ;
46886 PyObject *arg2 = (PyObject *) 0 ;
46887 bool result;
46888 void *argp1 = 0 ;
46889 int res1 = 0 ;
46890 PyObject * obj0 = 0 ;
46891 PyObject * obj1 = 0 ;
46892 char * kwnames[] = {
46893 (char *) "self",(char *) "item", NULL
46894 };
46895
46896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46900 }
46901 arg1 = reinterpret_cast< wxSizer * >(argp1);
46902 arg2 = obj1;
46903 {
46904 PyThreadState* __tstate = wxPyBeginAllowThreads();
46905 result = (bool)wxSizer_Remove(arg1,arg2);
46906 wxPyEndAllowThreads(__tstate);
46907 if (PyErr_Occurred()) SWIG_fail;
46908 }
46909 {
46910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46911 }
46912 return resultobj;
46913 fail:
46914 return NULL;
46915 }
46916
46917
46918 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46919 PyObject *resultobj = 0;
46920 wxSizer *arg1 = (wxSizer *) 0 ;
46921 PyObject *arg2 = (PyObject *) 0 ;
46922 bool result;
46923 void *argp1 = 0 ;
46924 int res1 = 0 ;
46925 PyObject * obj0 = 0 ;
46926 PyObject * obj1 = 0 ;
46927 char * kwnames[] = {
46928 (char *) "self",(char *) "item", NULL
46929 };
46930
46931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46933 if (!SWIG_IsOK(res1)) {
46934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46935 }
46936 arg1 = reinterpret_cast< wxSizer * >(argp1);
46937 arg2 = obj1;
46938 {
46939 PyThreadState* __tstate = wxPyBeginAllowThreads();
46940 result = (bool)wxSizer_Detach(arg1,arg2);
46941 wxPyEndAllowThreads(__tstate);
46942 if (PyErr_Occurred()) SWIG_fail;
46943 }
46944 {
46945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46946 }
46947 return resultobj;
46948 fail:
46949 return NULL;
46950 }
46951
46952
46953 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46954 PyObject *resultobj = 0;
46955 wxSizer *arg1 = (wxSizer *) 0 ;
46956 PyObject *arg2 = (PyObject *) 0 ;
46957 wxSizerItem *result = 0 ;
46958 void *argp1 = 0 ;
46959 int res1 = 0 ;
46960 PyObject * obj0 = 0 ;
46961 PyObject * obj1 = 0 ;
46962 char * kwnames[] = {
46963 (char *) "self",(char *) "item", NULL
46964 };
46965
46966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46968 if (!SWIG_IsOK(res1)) {
46969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46970 }
46971 arg1 = reinterpret_cast< wxSizer * >(argp1);
46972 arg2 = obj1;
46973 {
46974 PyThreadState* __tstate = wxPyBeginAllowThreads();
46975 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46976 wxPyEndAllowThreads(__tstate);
46977 if (PyErr_Occurred()) SWIG_fail;
46978 }
46979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46980 return resultobj;
46981 fail:
46982 return NULL;
46983 }
46984
46985
46986 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46987 PyObject *resultobj = 0;
46988 wxSizer *arg1 = (wxSizer *) 0 ;
46989 PyObject *arg2 = (PyObject *) 0 ;
46990 wxSize *arg3 = 0 ;
46991 void *argp1 = 0 ;
46992 int res1 = 0 ;
46993 wxSize temp3 ;
46994 PyObject * obj0 = 0 ;
46995 PyObject * obj1 = 0 ;
46996 PyObject * obj2 = 0 ;
46997 char * kwnames[] = {
46998 (char *) "self",(char *) "item",(char *) "size", NULL
46999 };
47000
47001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47003 if (!SWIG_IsOK(res1)) {
47004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47005 }
47006 arg1 = reinterpret_cast< wxSizer * >(argp1);
47007 arg2 = obj1;
47008 {
47009 arg3 = &temp3;
47010 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47011 }
47012 {
47013 PyThreadState* __tstate = wxPyBeginAllowThreads();
47014 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47015 wxPyEndAllowThreads(__tstate);
47016 if (PyErr_Occurred()) SWIG_fail;
47017 }
47018 resultobj = SWIG_Py_Void();
47019 return resultobj;
47020 fail:
47021 return NULL;
47022 }
47023
47024
47025 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47026 PyObject *resultobj = 0;
47027 wxSizer *arg1 = (wxSizer *) 0 ;
47028 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47029 wxSizerItem *result = 0 ;
47030 void *argp1 = 0 ;
47031 int res1 = 0 ;
47032 int res2 = 0 ;
47033 PyObject * obj0 = 0 ;
47034 PyObject * obj1 = 0 ;
47035 char * kwnames[] = {
47036 (char *) "self",(char *) "item", NULL
47037 };
47038
47039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47041 if (!SWIG_IsOK(res1)) {
47042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47043 }
47044 arg1 = reinterpret_cast< wxSizer * >(argp1);
47045 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47046 if (!SWIG_IsOK(res2)) {
47047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47048 }
47049 {
47050 PyThreadState* __tstate = wxPyBeginAllowThreads();
47051 result = (wxSizerItem *)(arg1)->Add(arg2);
47052 wxPyEndAllowThreads(__tstate);
47053 if (PyErr_Occurred()) SWIG_fail;
47054 }
47055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47056 return resultobj;
47057 fail:
47058 return NULL;
47059 }
47060
47061
47062 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47063 PyObject *resultobj = 0;
47064 wxSizer *arg1 = (wxSizer *) 0 ;
47065 size_t arg2 ;
47066 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47067 wxSizerItem *result = 0 ;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 size_t val2 ;
47071 int ecode2 = 0 ;
47072 int res3 = 0 ;
47073 PyObject * obj0 = 0 ;
47074 PyObject * obj1 = 0 ;
47075 PyObject * obj2 = 0 ;
47076 char * kwnames[] = {
47077 (char *) "self",(char *) "index",(char *) "item", NULL
47078 };
47079
47080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47082 if (!SWIG_IsOK(res1)) {
47083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47084 }
47085 arg1 = reinterpret_cast< wxSizer * >(argp1);
47086 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47087 if (!SWIG_IsOK(ecode2)) {
47088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47089 }
47090 arg2 = static_cast< size_t >(val2);
47091 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47092 if (!SWIG_IsOK(res3)) {
47093 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47094 }
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47109 PyObject *resultobj = 0;
47110 wxSizer *arg1 = (wxSizer *) 0 ;
47111 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47112 wxSizerItem *result = 0 ;
47113 void *argp1 = 0 ;
47114 int res1 = 0 ;
47115 int res2 = 0 ;
47116 PyObject * obj0 = 0 ;
47117 PyObject * obj1 = 0 ;
47118 char * kwnames[] = {
47119 (char *) "self",(char *) "item", NULL
47120 };
47121
47122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47124 if (!SWIG_IsOK(res1)) {
47125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47126 }
47127 arg1 = reinterpret_cast< wxSizer * >(argp1);
47128 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47129 if (!SWIG_IsOK(res2)) {
47130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47131 }
47132 {
47133 PyThreadState* __tstate = wxPyBeginAllowThreads();
47134 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47135 wxPyEndAllowThreads(__tstate);
47136 if (PyErr_Occurred()) SWIG_fail;
47137 }
47138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47139 return resultobj;
47140 fail:
47141 return NULL;
47142 }
47143
47144
47145 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47146 PyObject *resultobj = 0;
47147 wxSizer *arg1 = (wxSizer *) 0 ;
47148 int arg2 ;
47149 int arg3 ;
47150 int arg4 ;
47151 int arg5 ;
47152 void *argp1 = 0 ;
47153 int res1 = 0 ;
47154 int val2 ;
47155 int ecode2 = 0 ;
47156 int val3 ;
47157 int ecode3 = 0 ;
47158 int val4 ;
47159 int ecode4 = 0 ;
47160 int val5 ;
47161 int ecode5 = 0 ;
47162 PyObject * obj0 = 0 ;
47163 PyObject * obj1 = 0 ;
47164 PyObject * obj2 = 0 ;
47165 PyObject * obj3 = 0 ;
47166 PyObject * obj4 = 0 ;
47167 char * kwnames[] = {
47168 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47169 };
47170
47171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47173 if (!SWIG_IsOK(res1)) {
47174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47175 }
47176 arg1 = reinterpret_cast< wxSizer * >(argp1);
47177 ecode2 = SWIG_AsVal_int(obj1, &val2);
47178 if (!SWIG_IsOK(ecode2)) {
47179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47180 }
47181 arg2 = static_cast< int >(val2);
47182 ecode3 = SWIG_AsVal_int(obj2, &val3);
47183 if (!SWIG_IsOK(ecode3)) {
47184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47185 }
47186 arg3 = static_cast< int >(val3);
47187 ecode4 = SWIG_AsVal_int(obj3, &val4);
47188 if (!SWIG_IsOK(ecode4)) {
47189 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47190 }
47191 arg4 = static_cast< int >(val4);
47192 ecode5 = SWIG_AsVal_int(obj4, &val5);
47193 if (!SWIG_IsOK(ecode5)) {
47194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47195 }
47196 arg5 = static_cast< int >(val5);
47197 {
47198 PyThreadState* __tstate = wxPyBeginAllowThreads();
47199 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47200 wxPyEndAllowThreads(__tstate);
47201 if (PyErr_Occurred()) SWIG_fail;
47202 }
47203 resultobj = SWIG_Py_Void();
47204 return resultobj;
47205 fail:
47206 return NULL;
47207 }
47208
47209
47210 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47211 PyObject *resultobj = 0;
47212 wxSizer *arg1 = (wxSizer *) 0 ;
47213 wxSize *arg2 = 0 ;
47214 void *argp1 = 0 ;
47215 int res1 = 0 ;
47216 wxSize temp2 ;
47217 PyObject * obj0 = 0 ;
47218 PyObject * obj1 = 0 ;
47219 char * kwnames[] = {
47220 (char *) "self",(char *) "size", NULL
47221 };
47222
47223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47225 if (!SWIG_IsOK(res1)) {
47226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47227 }
47228 arg1 = reinterpret_cast< wxSizer * >(argp1);
47229 {
47230 arg2 = &temp2;
47231 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47232 }
47233 {
47234 PyThreadState* __tstate = wxPyBeginAllowThreads();
47235 (arg1)->SetMinSize((wxSize const &)*arg2);
47236 wxPyEndAllowThreads(__tstate);
47237 if (PyErr_Occurred()) SWIG_fail;
47238 }
47239 resultobj = SWIG_Py_Void();
47240 return resultobj;
47241 fail:
47242 return NULL;
47243 }
47244
47245
47246 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47247 PyObject *resultobj = 0;
47248 wxSizer *arg1 = (wxSizer *) 0 ;
47249 wxSize result;
47250 void *argp1 = 0 ;
47251 int res1 = 0 ;
47252 PyObject *swig_obj[1] ;
47253
47254 if (!args) SWIG_fail;
47255 swig_obj[0] = args;
47256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47257 if (!SWIG_IsOK(res1)) {
47258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47259 }
47260 arg1 = reinterpret_cast< wxSizer * >(argp1);
47261 {
47262 PyThreadState* __tstate = wxPyBeginAllowThreads();
47263 result = (arg1)->GetSize();
47264 wxPyEndAllowThreads(__tstate);
47265 if (PyErr_Occurred()) SWIG_fail;
47266 }
47267 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47268 return resultobj;
47269 fail:
47270 return NULL;
47271 }
47272
47273
47274 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47275 PyObject *resultobj = 0;
47276 wxSizer *arg1 = (wxSizer *) 0 ;
47277 wxPoint result;
47278 void *argp1 = 0 ;
47279 int res1 = 0 ;
47280 PyObject *swig_obj[1] ;
47281
47282 if (!args) SWIG_fail;
47283 swig_obj[0] = args;
47284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47285 if (!SWIG_IsOK(res1)) {
47286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47287 }
47288 arg1 = reinterpret_cast< wxSizer * >(argp1);
47289 {
47290 PyThreadState* __tstate = wxPyBeginAllowThreads();
47291 result = (arg1)->GetPosition();
47292 wxPyEndAllowThreads(__tstate);
47293 if (PyErr_Occurred()) SWIG_fail;
47294 }
47295 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47296 return resultobj;
47297 fail:
47298 return NULL;
47299 }
47300
47301
47302 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47303 PyObject *resultobj = 0;
47304 wxSizer *arg1 = (wxSizer *) 0 ;
47305 wxSize result;
47306 void *argp1 = 0 ;
47307 int res1 = 0 ;
47308 PyObject *swig_obj[1] ;
47309
47310 if (!args) SWIG_fail;
47311 swig_obj[0] = args;
47312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47313 if (!SWIG_IsOK(res1)) {
47314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47315 }
47316 arg1 = reinterpret_cast< wxSizer * >(argp1);
47317 {
47318 PyThreadState* __tstate = wxPyBeginAllowThreads();
47319 result = (arg1)->GetMinSize();
47320 wxPyEndAllowThreads(__tstate);
47321 if (PyErr_Occurred()) SWIG_fail;
47322 }
47323 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47324 return resultobj;
47325 fail:
47326 return NULL;
47327 }
47328
47329
47330 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47331 PyObject *resultobj = 0;
47332 wxSizer *arg1 = (wxSizer *) 0 ;
47333 void *argp1 = 0 ;
47334 int res1 = 0 ;
47335 PyObject *swig_obj[1] ;
47336
47337 if (!args) SWIG_fail;
47338 swig_obj[0] = args;
47339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47340 if (!SWIG_IsOK(res1)) {
47341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47342 }
47343 arg1 = reinterpret_cast< wxSizer * >(argp1);
47344 {
47345 PyThreadState* __tstate = wxPyBeginAllowThreads();
47346 (arg1)->RecalcSizes();
47347 wxPyEndAllowThreads(__tstate);
47348 if (PyErr_Occurred()) SWIG_fail;
47349 }
47350 resultobj = SWIG_Py_Void();
47351 return resultobj;
47352 fail:
47353 return NULL;
47354 }
47355
47356
47357 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47358 PyObject *resultobj = 0;
47359 wxSizer *arg1 = (wxSizer *) 0 ;
47360 wxSize result;
47361 void *argp1 = 0 ;
47362 int res1 = 0 ;
47363 PyObject *swig_obj[1] ;
47364
47365 if (!args) SWIG_fail;
47366 swig_obj[0] = args;
47367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47368 if (!SWIG_IsOK(res1)) {
47369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47370 }
47371 arg1 = reinterpret_cast< wxSizer * >(argp1);
47372 {
47373 PyThreadState* __tstate = wxPyBeginAllowThreads();
47374 result = (arg1)->CalcMin();
47375 wxPyEndAllowThreads(__tstate);
47376 if (PyErr_Occurred()) SWIG_fail;
47377 }
47378 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47379 return resultobj;
47380 fail:
47381 return NULL;
47382 }
47383
47384
47385 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47386 PyObject *resultobj = 0;
47387 wxSizer *arg1 = (wxSizer *) 0 ;
47388 void *argp1 = 0 ;
47389 int res1 = 0 ;
47390 PyObject *swig_obj[1] ;
47391
47392 if (!args) SWIG_fail;
47393 swig_obj[0] = args;
47394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47395 if (!SWIG_IsOK(res1)) {
47396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47397 }
47398 arg1 = reinterpret_cast< wxSizer * >(argp1);
47399 {
47400 PyThreadState* __tstate = wxPyBeginAllowThreads();
47401 (arg1)->Layout();
47402 wxPyEndAllowThreads(__tstate);
47403 if (PyErr_Occurred()) SWIG_fail;
47404 }
47405 resultobj = SWIG_Py_Void();
47406 return resultobj;
47407 fail:
47408 return NULL;
47409 }
47410
47411
47412 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47413 PyObject *resultobj = 0;
47414 wxSizer *arg1 = (wxSizer *) 0 ;
47415 wxWindow *arg2 = (wxWindow *) 0 ;
47416 wxSize result;
47417 void *argp1 = 0 ;
47418 int res1 = 0 ;
47419 void *argp2 = 0 ;
47420 int res2 = 0 ;
47421 PyObject * obj0 = 0 ;
47422 PyObject * obj1 = 0 ;
47423 char * kwnames[] = {
47424 (char *) "self",(char *) "window", NULL
47425 };
47426
47427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47429 if (!SWIG_IsOK(res1)) {
47430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47431 }
47432 arg1 = reinterpret_cast< wxSizer * >(argp1);
47433 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47434 if (!SWIG_IsOK(res2)) {
47435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47436 }
47437 arg2 = reinterpret_cast< wxWindow * >(argp2);
47438 {
47439 PyThreadState* __tstate = wxPyBeginAllowThreads();
47440 result = (arg1)->Fit(arg2);
47441 wxPyEndAllowThreads(__tstate);
47442 if (PyErr_Occurred()) SWIG_fail;
47443 }
47444 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47445 return resultobj;
47446 fail:
47447 return NULL;
47448 }
47449
47450
47451 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47452 PyObject *resultobj = 0;
47453 wxSizer *arg1 = (wxSizer *) 0 ;
47454 wxWindow *arg2 = (wxWindow *) 0 ;
47455 void *argp1 = 0 ;
47456 int res1 = 0 ;
47457 void *argp2 = 0 ;
47458 int res2 = 0 ;
47459 PyObject * obj0 = 0 ;
47460 PyObject * obj1 = 0 ;
47461 char * kwnames[] = {
47462 (char *) "self",(char *) "window", NULL
47463 };
47464
47465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47467 if (!SWIG_IsOK(res1)) {
47468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47469 }
47470 arg1 = reinterpret_cast< wxSizer * >(argp1);
47471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47472 if (!SWIG_IsOK(res2)) {
47473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47474 }
47475 arg2 = reinterpret_cast< wxWindow * >(argp2);
47476 {
47477 PyThreadState* __tstate = wxPyBeginAllowThreads();
47478 (arg1)->FitInside(arg2);
47479 wxPyEndAllowThreads(__tstate);
47480 if (PyErr_Occurred()) SWIG_fail;
47481 }
47482 resultobj = SWIG_Py_Void();
47483 return resultobj;
47484 fail:
47485 return NULL;
47486 }
47487
47488
47489 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47490 PyObject *resultobj = 0;
47491 wxSizer *arg1 = (wxSizer *) 0 ;
47492 wxWindow *arg2 = (wxWindow *) 0 ;
47493 void *argp1 = 0 ;
47494 int res1 = 0 ;
47495 void *argp2 = 0 ;
47496 int res2 = 0 ;
47497 PyObject * obj0 = 0 ;
47498 PyObject * obj1 = 0 ;
47499 char * kwnames[] = {
47500 (char *) "self",(char *) "window", NULL
47501 };
47502
47503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47505 if (!SWIG_IsOK(res1)) {
47506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47507 }
47508 arg1 = reinterpret_cast< wxSizer * >(argp1);
47509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47510 if (!SWIG_IsOK(res2)) {
47511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47512 }
47513 arg2 = reinterpret_cast< wxWindow * >(argp2);
47514 {
47515 PyThreadState* __tstate = wxPyBeginAllowThreads();
47516 (arg1)->SetSizeHints(arg2);
47517 wxPyEndAllowThreads(__tstate);
47518 if (PyErr_Occurred()) SWIG_fail;
47519 }
47520 resultobj = SWIG_Py_Void();
47521 return resultobj;
47522 fail:
47523 return NULL;
47524 }
47525
47526
47527 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47528 PyObject *resultobj = 0;
47529 wxSizer *arg1 = (wxSizer *) 0 ;
47530 wxWindow *arg2 = (wxWindow *) 0 ;
47531 void *argp1 = 0 ;
47532 int res1 = 0 ;
47533 void *argp2 = 0 ;
47534 int res2 = 0 ;
47535 PyObject * obj0 = 0 ;
47536 PyObject * obj1 = 0 ;
47537 char * kwnames[] = {
47538 (char *) "self",(char *) "window", NULL
47539 };
47540
47541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47543 if (!SWIG_IsOK(res1)) {
47544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47545 }
47546 arg1 = reinterpret_cast< wxSizer * >(argp1);
47547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47548 if (!SWIG_IsOK(res2)) {
47549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47550 }
47551 arg2 = reinterpret_cast< wxWindow * >(argp2);
47552 {
47553 PyThreadState* __tstate = wxPyBeginAllowThreads();
47554 (arg1)->SetVirtualSizeHints(arg2);
47555 wxPyEndAllowThreads(__tstate);
47556 if (PyErr_Occurred()) SWIG_fail;
47557 }
47558 resultobj = SWIG_Py_Void();
47559 return resultobj;
47560 fail:
47561 return NULL;
47562 }
47563
47564
47565 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47566 PyObject *resultobj = 0;
47567 wxSizer *arg1 = (wxSizer *) 0 ;
47568 bool arg2 = (bool) false ;
47569 void *argp1 = 0 ;
47570 int res1 = 0 ;
47571 bool val2 ;
47572 int ecode2 = 0 ;
47573 PyObject * obj0 = 0 ;
47574 PyObject * obj1 = 0 ;
47575 char * kwnames[] = {
47576 (char *) "self",(char *) "deleteWindows", NULL
47577 };
47578
47579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47581 if (!SWIG_IsOK(res1)) {
47582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47583 }
47584 arg1 = reinterpret_cast< wxSizer * >(argp1);
47585 if (obj1) {
47586 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47587 if (!SWIG_IsOK(ecode2)) {
47588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47589 }
47590 arg2 = static_cast< bool >(val2);
47591 }
47592 {
47593 PyThreadState* __tstate = wxPyBeginAllowThreads();
47594 (arg1)->Clear(arg2);
47595 wxPyEndAllowThreads(__tstate);
47596 if (PyErr_Occurred()) SWIG_fail;
47597 }
47598 resultobj = SWIG_Py_Void();
47599 return resultobj;
47600 fail:
47601 return NULL;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47606 PyObject *resultobj = 0;
47607 wxSizer *arg1 = (wxSizer *) 0 ;
47608 void *argp1 = 0 ;
47609 int res1 = 0 ;
47610 PyObject *swig_obj[1] ;
47611
47612 if (!args) SWIG_fail;
47613 swig_obj[0] = args;
47614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47615 if (!SWIG_IsOK(res1)) {
47616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47617 }
47618 arg1 = reinterpret_cast< wxSizer * >(argp1);
47619 {
47620 PyThreadState* __tstate = wxPyBeginAllowThreads();
47621 (arg1)->DeleteWindows();
47622 wxPyEndAllowThreads(__tstate);
47623 if (PyErr_Occurred()) SWIG_fail;
47624 }
47625 resultobj = SWIG_Py_Void();
47626 return resultobj;
47627 fail:
47628 return NULL;
47629 }
47630
47631
47632 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47633 PyObject *resultobj = 0;
47634 wxSizer *arg1 = (wxSizer *) 0 ;
47635 PyObject *result = 0 ;
47636 void *argp1 = 0 ;
47637 int res1 = 0 ;
47638 PyObject *swig_obj[1] ;
47639
47640 if (!args) SWIG_fail;
47641 swig_obj[0] = args;
47642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47643 if (!SWIG_IsOK(res1)) {
47644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47645 }
47646 arg1 = reinterpret_cast< wxSizer * >(argp1);
47647 {
47648 PyThreadState* __tstate = wxPyBeginAllowThreads();
47649 result = (PyObject *)wxSizer_GetChildren(arg1);
47650 wxPyEndAllowThreads(__tstate);
47651 if (PyErr_Occurred()) SWIG_fail;
47652 }
47653 resultobj = result;
47654 return resultobj;
47655 fail:
47656 return NULL;
47657 }
47658
47659
47660 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47661 PyObject *resultobj = 0;
47662 wxSizer *arg1 = (wxSizer *) 0 ;
47663 PyObject *arg2 = (PyObject *) 0 ;
47664 bool arg3 = (bool) true ;
47665 bool arg4 = (bool) false ;
47666 bool result;
47667 void *argp1 = 0 ;
47668 int res1 = 0 ;
47669 bool val3 ;
47670 int ecode3 = 0 ;
47671 bool val4 ;
47672 int ecode4 = 0 ;
47673 PyObject * obj0 = 0 ;
47674 PyObject * obj1 = 0 ;
47675 PyObject * obj2 = 0 ;
47676 PyObject * obj3 = 0 ;
47677 char * kwnames[] = {
47678 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47679 };
47680
47681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47683 if (!SWIG_IsOK(res1)) {
47684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47685 }
47686 arg1 = reinterpret_cast< wxSizer * >(argp1);
47687 arg2 = obj1;
47688 if (obj2) {
47689 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47690 if (!SWIG_IsOK(ecode3)) {
47691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47692 }
47693 arg3 = static_cast< bool >(val3);
47694 }
47695 if (obj3) {
47696 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47697 if (!SWIG_IsOK(ecode4)) {
47698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47699 }
47700 arg4 = static_cast< bool >(val4);
47701 }
47702 {
47703 PyThreadState* __tstate = wxPyBeginAllowThreads();
47704 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47705 wxPyEndAllowThreads(__tstate);
47706 if (PyErr_Occurred()) SWIG_fail;
47707 }
47708 {
47709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47710 }
47711 return resultobj;
47712 fail:
47713 return NULL;
47714 }
47715
47716
47717 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47718 PyObject *resultobj = 0;
47719 wxSizer *arg1 = (wxSizer *) 0 ;
47720 PyObject *arg2 = (PyObject *) 0 ;
47721 bool result;
47722 void *argp1 = 0 ;
47723 int res1 = 0 ;
47724 PyObject * obj0 = 0 ;
47725 PyObject * obj1 = 0 ;
47726 char * kwnames[] = {
47727 (char *) "self",(char *) "item", NULL
47728 };
47729
47730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47732 if (!SWIG_IsOK(res1)) {
47733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47734 }
47735 arg1 = reinterpret_cast< wxSizer * >(argp1);
47736 arg2 = obj1;
47737 {
47738 PyThreadState* __tstate = wxPyBeginAllowThreads();
47739 result = (bool)wxSizer_IsShown(arg1,arg2);
47740 wxPyEndAllowThreads(__tstate);
47741 if (PyErr_Occurred()) SWIG_fail;
47742 }
47743 {
47744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47745 }
47746 return resultobj;
47747 fail:
47748 return NULL;
47749 }
47750
47751
47752 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47753 PyObject *resultobj = 0;
47754 wxSizer *arg1 = (wxSizer *) 0 ;
47755 bool arg2 ;
47756 void *argp1 = 0 ;
47757 int res1 = 0 ;
47758 bool val2 ;
47759 int ecode2 = 0 ;
47760 PyObject * obj0 = 0 ;
47761 PyObject * obj1 = 0 ;
47762 char * kwnames[] = {
47763 (char *) "self",(char *) "show", NULL
47764 };
47765
47766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47768 if (!SWIG_IsOK(res1)) {
47769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47770 }
47771 arg1 = reinterpret_cast< wxSizer * >(argp1);
47772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47773 if (!SWIG_IsOK(ecode2)) {
47774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47775 }
47776 arg2 = static_cast< bool >(val2);
47777 {
47778 PyThreadState* __tstate = wxPyBeginAllowThreads();
47779 (arg1)->ShowItems(arg2);
47780 wxPyEndAllowThreads(__tstate);
47781 if (PyErr_Occurred()) SWIG_fail;
47782 }
47783 resultobj = SWIG_Py_Void();
47784 return resultobj;
47785 fail:
47786 return NULL;
47787 }
47788
47789
47790 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47791 PyObject *obj;
47792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47793 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47794 return SWIG_Py_Void();
47795 }
47796
47797 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47798 PyObject *resultobj = 0;
47799 wxPySizer *result = 0 ;
47800
47801 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47802 {
47803 PyThreadState* __tstate = wxPyBeginAllowThreads();
47804 result = (wxPySizer *)new wxPySizer();
47805 wxPyEndAllowThreads(__tstate);
47806 if (PyErr_Occurred()) SWIG_fail;
47807 }
47808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47809 return resultobj;
47810 fail:
47811 return NULL;
47812 }
47813
47814
47815 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47816 PyObject *resultobj = 0;
47817 wxPySizer *arg1 = (wxPySizer *) 0 ;
47818 PyObject *arg2 = (PyObject *) 0 ;
47819 PyObject *arg3 = (PyObject *) 0 ;
47820 void *argp1 = 0 ;
47821 int res1 = 0 ;
47822 PyObject * obj0 = 0 ;
47823 PyObject * obj1 = 0 ;
47824 PyObject * obj2 = 0 ;
47825 char * kwnames[] = {
47826 (char *) "self",(char *) "self",(char *) "_class", NULL
47827 };
47828
47829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47831 if (!SWIG_IsOK(res1)) {
47832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47833 }
47834 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47835 arg2 = obj1;
47836 arg3 = obj2;
47837 {
47838 PyThreadState* __tstate = wxPyBeginAllowThreads();
47839 (arg1)->_setCallbackInfo(arg2,arg3);
47840 wxPyEndAllowThreads(__tstate);
47841 if (PyErr_Occurred()) SWIG_fail;
47842 }
47843 resultobj = SWIG_Py_Void();
47844 return resultobj;
47845 fail:
47846 return NULL;
47847 }
47848
47849
47850 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47851 PyObject *obj;
47852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47853 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47854 return SWIG_Py_Void();
47855 }
47856
47857 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47858 return SWIG_Python_InitShadowInstance(args);
47859 }
47860
47861 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47862 PyObject *resultobj = 0;
47863 int arg1 = (int) wxHORIZONTAL ;
47864 wxBoxSizer *result = 0 ;
47865 int val1 ;
47866 int ecode1 = 0 ;
47867 PyObject * obj0 = 0 ;
47868 char * kwnames[] = {
47869 (char *) "orient", NULL
47870 };
47871
47872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47873 if (obj0) {
47874 ecode1 = SWIG_AsVal_int(obj0, &val1);
47875 if (!SWIG_IsOK(ecode1)) {
47876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47877 }
47878 arg1 = static_cast< int >(val1);
47879 }
47880 {
47881 PyThreadState* __tstate = wxPyBeginAllowThreads();
47882 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47883 wxPyEndAllowThreads(__tstate);
47884 if (PyErr_Occurred()) SWIG_fail;
47885 }
47886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47887 return resultobj;
47888 fail:
47889 return NULL;
47890 }
47891
47892
47893 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47894 PyObject *resultobj = 0;
47895 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47896 int result;
47897 void *argp1 = 0 ;
47898 int res1 = 0 ;
47899 PyObject *swig_obj[1] ;
47900
47901 if (!args) SWIG_fail;
47902 swig_obj[0] = args;
47903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47904 if (!SWIG_IsOK(res1)) {
47905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47906 }
47907 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 result = (int)(arg1)->GetOrientation();
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = SWIG_From_int(static_cast< int >(result));
47915 return resultobj;
47916 fail:
47917 return NULL;
47918 }
47919
47920
47921 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47922 PyObject *resultobj = 0;
47923 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47924 int arg2 ;
47925 void *argp1 = 0 ;
47926 int res1 = 0 ;
47927 int val2 ;
47928 int ecode2 = 0 ;
47929 PyObject * obj0 = 0 ;
47930 PyObject * obj1 = 0 ;
47931 char * kwnames[] = {
47932 (char *) "self",(char *) "orient", NULL
47933 };
47934
47935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47937 if (!SWIG_IsOK(res1)) {
47938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47939 }
47940 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47941 ecode2 = SWIG_AsVal_int(obj1, &val2);
47942 if (!SWIG_IsOK(ecode2)) {
47943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47944 }
47945 arg2 = static_cast< int >(val2);
47946 {
47947 PyThreadState* __tstate = wxPyBeginAllowThreads();
47948 (arg1)->SetOrientation(arg2);
47949 wxPyEndAllowThreads(__tstate);
47950 if (PyErr_Occurred()) SWIG_fail;
47951 }
47952 resultobj = SWIG_Py_Void();
47953 return resultobj;
47954 fail:
47955 return NULL;
47956 }
47957
47958
47959 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47960 PyObject *obj;
47961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47962 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47963 return SWIG_Py_Void();
47964 }
47965
47966 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47967 return SWIG_Python_InitShadowInstance(args);
47968 }
47969
47970 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47971 PyObject *resultobj = 0;
47972 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47973 int arg2 = (int) wxHORIZONTAL ;
47974 wxStaticBoxSizer *result = 0 ;
47975 void *argp1 = 0 ;
47976 int res1 = 0 ;
47977 int val2 ;
47978 int ecode2 = 0 ;
47979 PyObject * obj0 = 0 ;
47980 PyObject * obj1 = 0 ;
47981 char * kwnames[] = {
47982 (char *) "box",(char *) "orient", NULL
47983 };
47984
47985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47989 }
47990 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47991 if (obj1) {
47992 ecode2 = SWIG_AsVal_int(obj1, &val2);
47993 if (!SWIG_IsOK(ecode2)) {
47994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47995 }
47996 arg2 = static_cast< int >(val2);
47997 }
47998 {
47999 PyThreadState* __tstate = wxPyBeginAllowThreads();
48000 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48001 wxPyEndAllowThreads(__tstate);
48002 if (PyErr_Occurred()) SWIG_fail;
48003 }
48004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48005 return resultobj;
48006 fail:
48007 return NULL;
48008 }
48009
48010
48011 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48012 PyObject *resultobj = 0;
48013 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48014 wxStaticBox *result = 0 ;
48015 void *argp1 = 0 ;
48016 int res1 = 0 ;
48017 PyObject *swig_obj[1] ;
48018
48019 if (!args) SWIG_fail;
48020 swig_obj[0] = args;
48021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48022 if (!SWIG_IsOK(res1)) {
48023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48024 }
48025 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48026 {
48027 PyThreadState* __tstate = wxPyBeginAllowThreads();
48028 result = (wxStaticBox *)(arg1)->GetStaticBox();
48029 wxPyEndAllowThreads(__tstate);
48030 if (PyErr_Occurred()) SWIG_fail;
48031 }
48032 {
48033 resultobj = wxPyMake_wxObject(result, (bool)0);
48034 }
48035 return resultobj;
48036 fail:
48037 return NULL;
48038 }
48039
48040
48041 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48042 PyObject *obj;
48043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48044 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48045 return SWIG_Py_Void();
48046 }
48047
48048 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48049 return SWIG_Python_InitShadowInstance(args);
48050 }
48051
48052 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48053 PyObject *resultobj = 0;
48054 int arg1 = (int) 1 ;
48055 int arg2 = (int) 0 ;
48056 int arg3 = (int) 0 ;
48057 int arg4 = (int) 0 ;
48058 wxGridSizer *result = 0 ;
48059 int val1 ;
48060 int ecode1 = 0 ;
48061 int val2 ;
48062 int ecode2 = 0 ;
48063 int val3 ;
48064 int ecode3 = 0 ;
48065 int val4 ;
48066 int ecode4 = 0 ;
48067 PyObject * obj0 = 0 ;
48068 PyObject * obj1 = 0 ;
48069 PyObject * obj2 = 0 ;
48070 PyObject * obj3 = 0 ;
48071 char * kwnames[] = {
48072 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48073 };
48074
48075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48076 if (obj0) {
48077 ecode1 = SWIG_AsVal_int(obj0, &val1);
48078 if (!SWIG_IsOK(ecode1)) {
48079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48080 }
48081 arg1 = static_cast< int >(val1);
48082 }
48083 if (obj1) {
48084 ecode2 = SWIG_AsVal_int(obj1, &val2);
48085 if (!SWIG_IsOK(ecode2)) {
48086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48087 }
48088 arg2 = static_cast< int >(val2);
48089 }
48090 if (obj2) {
48091 ecode3 = SWIG_AsVal_int(obj2, &val3);
48092 if (!SWIG_IsOK(ecode3)) {
48093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48094 }
48095 arg3 = static_cast< int >(val3);
48096 }
48097 if (obj3) {
48098 ecode4 = SWIG_AsVal_int(obj3, &val4);
48099 if (!SWIG_IsOK(ecode4)) {
48100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48101 }
48102 arg4 = static_cast< int >(val4);
48103 }
48104 {
48105 PyThreadState* __tstate = wxPyBeginAllowThreads();
48106 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48107 wxPyEndAllowThreads(__tstate);
48108 if (PyErr_Occurred()) SWIG_fail;
48109 }
48110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48111 return resultobj;
48112 fail:
48113 return NULL;
48114 }
48115
48116
48117 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48118 PyObject *resultobj = 0;
48119 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48120 int arg2 ;
48121 void *argp1 = 0 ;
48122 int res1 = 0 ;
48123 int val2 ;
48124 int ecode2 = 0 ;
48125 PyObject * obj0 = 0 ;
48126 PyObject * obj1 = 0 ;
48127 char * kwnames[] = {
48128 (char *) "self",(char *) "cols", NULL
48129 };
48130
48131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48133 if (!SWIG_IsOK(res1)) {
48134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48135 }
48136 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48137 ecode2 = SWIG_AsVal_int(obj1, &val2);
48138 if (!SWIG_IsOK(ecode2)) {
48139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48140 }
48141 arg2 = static_cast< int >(val2);
48142 {
48143 PyThreadState* __tstate = wxPyBeginAllowThreads();
48144 (arg1)->SetCols(arg2);
48145 wxPyEndAllowThreads(__tstate);
48146 if (PyErr_Occurred()) SWIG_fail;
48147 }
48148 resultobj = SWIG_Py_Void();
48149 return resultobj;
48150 fail:
48151 return NULL;
48152 }
48153
48154
48155 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48156 PyObject *resultobj = 0;
48157 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48158 int arg2 ;
48159 void *argp1 = 0 ;
48160 int res1 = 0 ;
48161 int val2 ;
48162 int ecode2 = 0 ;
48163 PyObject * obj0 = 0 ;
48164 PyObject * obj1 = 0 ;
48165 char * kwnames[] = {
48166 (char *) "self",(char *) "rows", NULL
48167 };
48168
48169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48171 if (!SWIG_IsOK(res1)) {
48172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48173 }
48174 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48175 ecode2 = SWIG_AsVal_int(obj1, &val2);
48176 if (!SWIG_IsOK(ecode2)) {
48177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48178 }
48179 arg2 = static_cast< int >(val2);
48180 {
48181 PyThreadState* __tstate = wxPyBeginAllowThreads();
48182 (arg1)->SetRows(arg2);
48183 wxPyEndAllowThreads(__tstate);
48184 if (PyErr_Occurred()) SWIG_fail;
48185 }
48186 resultobj = SWIG_Py_Void();
48187 return resultobj;
48188 fail:
48189 return NULL;
48190 }
48191
48192
48193 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48194 PyObject *resultobj = 0;
48195 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48196 int arg2 ;
48197 void *argp1 = 0 ;
48198 int res1 = 0 ;
48199 int val2 ;
48200 int ecode2 = 0 ;
48201 PyObject * obj0 = 0 ;
48202 PyObject * obj1 = 0 ;
48203 char * kwnames[] = {
48204 (char *) "self",(char *) "gap", NULL
48205 };
48206
48207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48209 if (!SWIG_IsOK(res1)) {
48210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48211 }
48212 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48213 ecode2 = SWIG_AsVal_int(obj1, &val2);
48214 if (!SWIG_IsOK(ecode2)) {
48215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48216 }
48217 arg2 = static_cast< int >(val2);
48218 {
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 (arg1)->SetVGap(arg2);
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 resultobj = SWIG_Py_Void();
48225 return resultobj;
48226 fail:
48227 return NULL;
48228 }
48229
48230
48231 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48232 PyObject *resultobj = 0;
48233 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48234 int arg2 ;
48235 void *argp1 = 0 ;
48236 int res1 = 0 ;
48237 int val2 ;
48238 int ecode2 = 0 ;
48239 PyObject * obj0 = 0 ;
48240 PyObject * obj1 = 0 ;
48241 char * kwnames[] = {
48242 (char *) "self",(char *) "gap", NULL
48243 };
48244
48245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48247 if (!SWIG_IsOK(res1)) {
48248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48249 }
48250 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48251 ecode2 = SWIG_AsVal_int(obj1, &val2);
48252 if (!SWIG_IsOK(ecode2)) {
48253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48254 }
48255 arg2 = static_cast< int >(val2);
48256 {
48257 PyThreadState* __tstate = wxPyBeginAllowThreads();
48258 (arg1)->SetHGap(arg2);
48259 wxPyEndAllowThreads(__tstate);
48260 if (PyErr_Occurred()) SWIG_fail;
48261 }
48262 resultobj = SWIG_Py_Void();
48263 return resultobj;
48264 fail:
48265 return NULL;
48266 }
48267
48268
48269 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48270 PyObject *resultobj = 0;
48271 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48272 int result;
48273 void *argp1 = 0 ;
48274 int res1 = 0 ;
48275 PyObject *swig_obj[1] ;
48276
48277 if (!args) SWIG_fail;
48278 swig_obj[0] = args;
48279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48280 if (!SWIG_IsOK(res1)) {
48281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48282 }
48283 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48284 {
48285 PyThreadState* __tstate = wxPyBeginAllowThreads();
48286 result = (int)(arg1)->GetCols();
48287 wxPyEndAllowThreads(__tstate);
48288 if (PyErr_Occurred()) SWIG_fail;
48289 }
48290 resultobj = SWIG_From_int(static_cast< int >(result));
48291 return resultobj;
48292 fail:
48293 return NULL;
48294 }
48295
48296
48297 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48298 PyObject *resultobj = 0;
48299 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48300 int result;
48301 void *argp1 = 0 ;
48302 int res1 = 0 ;
48303 PyObject *swig_obj[1] ;
48304
48305 if (!args) SWIG_fail;
48306 swig_obj[0] = args;
48307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48308 if (!SWIG_IsOK(res1)) {
48309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48310 }
48311 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48312 {
48313 PyThreadState* __tstate = wxPyBeginAllowThreads();
48314 result = (int)(arg1)->GetRows();
48315 wxPyEndAllowThreads(__tstate);
48316 if (PyErr_Occurred()) SWIG_fail;
48317 }
48318 resultobj = SWIG_From_int(static_cast< int >(result));
48319 return resultobj;
48320 fail:
48321 return NULL;
48322 }
48323
48324
48325 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48326 PyObject *resultobj = 0;
48327 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48328 int result;
48329 void *argp1 = 0 ;
48330 int res1 = 0 ;
48331 PyObject *swig_obj[1] ;
48332
48333 if (!args) SWIG_fail;
48334 swig_obj[0] = args;
48335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48336 if (!SWIG_IsOK(res1)) {
48337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48338 }
48339 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48340 {
48341 PyThreadState* __tstate = wxPyBeginAllowThreads();
48342 result = (int)(arg1)->GetVGap();
48343 wxPyEndAllowThreads(__tstate);
48344 if (PyErr_Occurred()) SWIG_fail;
48345 }
48346 resultobj = SWIG_From_int(static_cast< int >(result));
48347 return resultobj;
48348 fail:
48349 return NULL;
48350 }
48351
48352
48353 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48354 PyObject *resultobj = 0;
48355 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48356 int result;
48357 void *argp1 = 0 ;
48358 int res1 = 0 ;
48359 PyObject *swig_obj[1] ;
48360
48361 if (!args) SWIG_fail;
48362 swig_obj[0] = args;
48363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48364 if (!SWIG_IsOK(res1)) {
48365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48366 }
48367 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48368 {
48369 PyThreadState* __tstate = wxPyBeginAllowThreads();
48370 result = (int)(arg1)->GetHGap();
48371 wxPyEndAllowThreads(__tstate);
48372 if (PyErr_Occurred()) SWIG_fail;
48373 }
48374 resultobj = SWIG_From_int(static_cast< int >(result));
48375 return resultobj;
48376 fail:
48377 return NULL;
48378 }
48379
48380
48381 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48382 PyObject *obj;
48383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48384 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48385 return SWIG_Py_Void();
48386 }
48387
48388 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48389 return SWIG_Python_InitShadowInstance(args);
48390 }
48391
48392 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48393 PyObject *resultobj = 0;
48394 int arg1 = (int) 1 ;
48395 int arg2 = (int) 0 ;
48396 int arg3 = (int) 0 ;
48397 int arg4 = (int) 0 ;
48398 wxFlexGridSizer *result = 0 ;
48399 int val1 ;
48400 int ecode1 = 0 ;
48401 int val2 ;
48402 int ecode2 = 0 ;
48403 int val3 ;
48404 int ecode3 = 0 ;
48405 int val4 ;
48406 int ecode4 = 0 ;
48407 PyObject * obj0 = 0 ;
48408 PyObject * obj1 = 0 ;
48409 PyObject * obj2 = 0 ;
48410 PyObject * obj3 = 0 ;
48411 char * kwnames[] = {
48412 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48413 };
48414
48415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48416 if (obj0) {
48417 ecode1 = SWIG_AsVal_int(obj0, &val1);
48418 if (!SWIG_IsOK(ecode1)) {
48419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48420 }
48421 arg1 = static_cast< int >(val1);
48422 }
48423 if (obj1) {
48424 ecode2 = SWIG_AsVal_int(obj1, &val2);
48425 if (!SWIG_IsOK(ecode2)) {
48426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48427 }
48428 arg2 = static_cast< int >(val2);
48429 }
48430 if (obj2) {
48431 ecode3 = SWIG_AsVal_int(obj2, &val3);
48432 if (!SWIG_IsOK(ecode3)) {
48433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48434 }
48435 arg3 = static_cast< int >(val3);
48436 }
48437 if (obj3) {
48438 ecode4 = SWIG_AsVal_int(obj3, &val4);
48439 if (!SWIG_IsOK(ecode4)) {
48440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48441 }
48442 arg4 = static_cast< int >(val4);
48443 }
48444 {
48445 PyThreadState* __tstate = wxPyBeginAllowThreads();
48446 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48447 wxPyEndAllowThreads(__tstate);
48448 if (PyErr_Occurred()) SWIG_fail;
48449 }
48450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48451 return resultobj;
48452 fail:
48453 return NULL;
48454 }
48455
48456
48457 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48458 PyObject *resultobj = 0;
48459 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48460 size_t arg2 ;
48461 int arg3 = (int) 0 ;
48462 void *argp1 = 0 ;
48463 int res1 = 0 ;
48464 size_t val2 ;
48465 int ecode2 = 0 ;
48466 int val3 ;
48467 int ecode3 = 0 ;
48468 PyObject * obj0 = 0 ;
48469 PyObject * obj1 = 0 ;
48470 PyObject * obj2 = 0 ;
48471 char * kwnames[] = {
48472 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48473 };
48474
48475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48477 if (!SWIG_IsOK(res1)) {
48478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48479 }
48480 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48481 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48482 if (!SWIG_IsOK(ecode2)) {
48483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48484 }
48485 arg2 = static_cast< size_t >(val2);
48486 if (obj2) {
48487 ecode3 = SWIG_AsVal_int(obj2, &val3);
48488 if (!SWIG_IsOK(ecode3)) {
48489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48490 }
48491 arg3 = static_cast< int >(val3);
48492 }
48493 {
48494 PyThreadState* __tstate = wxPyBeginAllowThreads();
48495 (arg1)->AddGrowableRow(arg2,arg3);
48496 wxPyEndAllowThreads(__tstate);
48497 if (PyErr_Occurred()) SWIG_fail;
48498 }
48499 resultobj = SWIG_Py_Void();
48500 return resultobj;
48501 fail:
48502 return NULL;
48503 }
48504
48505
48506 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48507 PyObject *resultobj = 0;
48508 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48509 size_t arg2 ;
48510 void *argp1 = 0 ;
48511 int res1 = 0 ;
48512 size_t val2 ;
48513 int ecode2 = 0 ;
48514 PyObject * obj0 = 0 ;
48515 PyObject * obj1 = 0 ;
48516 char * kwnames[] = {
48517 (char *) "self",(char *) "idx", NULL
48518 };
48519
48520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48522 if (!SWIG_IsOK(res1)) {
48523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48524 }
48525 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48526 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48527 if (!SWIG_IsOK(ecode2)) {
48528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48529 }
48530 arg2 = static_cast< size_t >(val2);
48531 {
48532 PyThreadState* __tstate = wxPyBeginAllowThreads();
48533 (arg1)->RemoveGrowableRow(arg2);
48534 wxPyEndAllowThreads(__tstate);
48535 if (PyErr_Occurred()) SWIG_fail;
48536 }
48537 resultobj = SWIG_Py_Void();
48538 return resultobj;
48539 fail:
48540 return NULL;
48541 }
48542
48543
48544 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48545 PyObject *resultobj = 0;
48546 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48547 size_t arg2 ;
48548 int arg3 = (int) 0 ;
48549 void *argp1 = 0 ;
48550 int res1 = 0 ;
48551 size_t val2 ;
48552 int ecode2 = 0 ;
48553 int val3 ;
48554 int ecode3 = 0 ;
48555 PyObject * obj0 = 0 ;
48556 PyObject * obj1 = 0 ;
48557 PyObject * obj2 = 0 ;
48558 char * kwnames[] = {
48559 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48560 };
48561
48562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48564 if (!SWIG_IsOK(res1)) {
48565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48566 }
48567 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48568 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48569 if (!SWIG_IsOK(ecode2)) {
48570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48571 }
48572 arg2 = static_cast< size_t >(val2);
48573 if (obj2) {
48574 ecode3 = SWIG_AsVal_int(obj2, &val3);
48575 if (!SWIG_IsOK(ecode3)) {
48576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48577 }
48578 arg3 = static_cast< int >(val3);
48579 }
48580 {
48581 PyThreadState* __tstate = wxPyBeginAllowThreads();
48582 (arg1)->AddGrowableCol(arg2,arg3);
48583 wxPyEndAllowThreads(__tstate);
48584 if (PyErr_Occurred()) SWIG_fail;
48585 }
48586 resultobj = SWIG_Py_Void();
48587 return resultobj;
48588 fail:
48589 return NULL;
48590 }
48591
48592
48593 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48594 PyObject *resultobj = 0;
48595 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48596 size_t arg2 ;
48597 void *argp1 = 0 ;
48598 int res1 = 0 ;
48599 size_t val2 ;
48600 int ecode2 = 0 ;
48601 PyObject * obj0 = 0 ;
48602 PyObject * obj1 = 0 ;
48603 char * kwnames[] = {
48604 (char *) "self",(char *) "idx", NULL
48605 };
48606
48607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48609 if (!SWIG_IsOK(res1)) {
48610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48611 }
48612 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48613 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48614 if (!SWIG_IsOK(ecode2)) {
48615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48616 }
48617 arg2 = static_cast< size_t >(val2);
48618 {
48619 PyThreadState* __tstate = wxPyBeginAllowThreads();
48620 (arg1)->RemoveGrowableCol(arg2);
48621 wxPyEndAllowThreads(__tstate);
48622 if (PyErr_Occurred()) SWIG_fail;
48623 }
48624 resultobj = SWIG_Py_Void();
48625 return resultobj;
48626 fail:
48627 return NULL;
48628 }
48629
48630
48631 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48632 PyObject *resultobj = 0;
48633 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48634 int arg2 ;
48635 void *argp1 = 0 ;
48636 int res1 = 0 ;
48637 int val2 ;
48638 int ecode2 = 0 ;
48639 PyObject * obj0 = 0 ;
48640 PyObject * obj1 = 0 ;
48641 char * kwnames[] = {
48642 (char *) "self",(char *) "direction", NULL
48643 };
48644
48645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48647 if (!SWIG_IsOK(res1)) {
48648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48649 }
48650 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48651 ecode2 = SWIG_AsVal_int(obj1, &val2);
48652 if (!SWIG_IsOK(ecode2)) {
48653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48654 }
48655 arg2 = static_cast< int >(val2);
48656 {
48657 PyThreadState* __tstate = wxPyBeginAllowThreads();
48658 (arg1)->SetFlexibleDirection(arg2);
48659 wxPyEndAllowThreads(__tstate);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 }
48662 resultobj = SWIG_Py_Void();
48663 return resultobj;
48664 fail:
48665 return NULL;
48666 }
48667
48668
48669 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48670 PyObject *resultobj = 0;
48671 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48672 int result;
48673 void *argp1 = 0 ;
48674 int res1 = 0 ;
48675 PyObject *swig_obj[1] ;
48676
48677 if (!args) SWIG_fail;
48678 swig_obj[0] = args;
48679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48680 if (!SWIG_IsOK(res1)) {
48681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48682 }
48683 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48684 {
48685 PyThreadState* __tstate = wxPyBeginAllowThreads();
48686 result = (int)(arg1)->GetFlexibleDirection();
48687 wxPyEndAllowThreads(__tstate);
48688 if (PyErr_Occurred()) SWIG_fail;
48689 }
48690 resultobj = SWIG_From_int(static_cast< int >(result));
48691 return resultobj;
48692 fail:
48693 return NULL;
48694 }
48695
48696
48697 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48698 PyObject *resultobj = 0;
48699 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48700 wxFlexSizerGrowMode arg2 ;
48701 void *argp1 = 0 ;
48702 int res1 = 0 ;
48703 int val2 ;
48704 int ecode2 = 0 ;
48705 PyObject * obj0 = 0 ;
48706 PyObject * obj1 = 0 ;
48707 char * kwnames[] = {
48708 (char *) "self",(char *) "mode", NULL
48709 };
48710
48711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48713 if (!SWIG_IsOK(res1)) {
48714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48715 }
48716 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48717 ecode2 = SWIG_AsVal_int(obj1, &val2);
48718 if (!SWIG_IsOK(ecode2)) {
48719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48720 }
48721 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48722 {
48723 PyThreadState* __tstate = wxPyBeginAllowThreads();
48724 (arg1)->SetNonFlexibleGrowMode(arg2);
48725 wxPyEndAllowThreads(__tstate);
48726 if (PyErr_Occurred()) SWIG_fail;
48727 }
48728 resultobj = SWIG_Py_Void();
48729 return resultobj;
48730 fail:
48731 return NULL;
48732 }
48733
48734
48735 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48736 PyObject *resultobj = 0;
48737 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48738 wxFlexSizerGrowMode result;
48739 void *argp1 = 0 ;
48740 int res1 = 0 ;
48741 PyObject *swig_obj[1] ;
48742
48743 if (!args) SWIG_fail;
48744 swig_obj[0] = args;
48745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48746 if (!SWIG_IsOK(res1)) {
48747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48748 }
48749 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48750 {
48751 PyThreadState* __tstate = wxPyBeginAllowThreads();
48752 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48753 wxPyEndAllowThreads(__tstate);
48754 if (PyErr_Occurred()) SWIG_fail;
48755 }
48756 resultobj = SWIG_From_int(static_cast< int >(result));
48757 return resultobj;
48758 fail:
48759 return NULL;
48760 }
48761
48762
48763 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48764 PyObject *resultobj = 0;
48765 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48766 wxArrayInt *result = 0 ;
48767 void *argp1 = 0 ;
48768 int res1 = 0 ;
48769 PyObject *swig_obj[1] ;
48770
48771 if (!args) SWIG_fail;
48772 swig_obj[0] = args;
48773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48774 if (!SWIG_IsOK(res1)) {
48775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48776 }
48777 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48778 {
48779 PyThreadState* __tstate = wxPyBeginAllowThreads();
48780 {
48781 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48782 result = (wxArrayInt *) &_result_ref;
48783 }
48784 wxPyEndAllowThreads(__tstate);
48785 if (PyErr_Occurred()) SWIG_fail;
48786 }
48787 {
48788 resultobj = PyList_New(0);
48789 size_t idx;
48790 for (idx = 0; idx < result->GetCount(); idx += 1) {
48791 PyObject* val = PyInt_FromLong( result->Item(idx) );
48792 PyList_Append(resultobj, val);
48793 Py_DECREF(val);
48794 }
48795 }
48796 return resultobj;
48797 fail:
48798 return NULL;
48799 }
48800
48801
48802 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48803 PyObject *resultobj = 0;
48804 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48805 wxArrayInt *result = 0 ;
48806 void *argp1 = 0 ;
48807 int res1 = 0 ;
48808 PyObject *swig_obj[1] ;
48809
48810 if (!args) SWIG_fail;
48811 swig_obj[0] = args;
48812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48813 if (!SWIG_IsOK(res1)) {
48814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48815 }
48816 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48817 {
48818 PyThreadState* __tstate = wxPyBeginAllowThreads();
48819 {
48820 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48821 result = (wxArrayInt *) &_result_ref;
48822 }
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 {
48827 resultobj = PyList_New(0);
48828 size_t idx;
48829 for (idx = 0; idx < result->GetCount(); idx += 1) {
48830 PyObject* val = PyInt_FromLong( result->Item(idx) );
48831 PyList_Append(resultobj, val);
48832 Py_DECREF(val);
48833 }
48834 }
48835 return resultobj;
48836 fail:
48837 return NULL;
48838 }
48839
48840
48841 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48842 PyObject *obj;
48843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48844 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48845 return SWIG_Py_Void();
48846 }
48847
48848 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48849 return SWIG_Python_InitShadowInstance(args);
48850 }
48851
48852 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48853 PyObject *resultobj = 0;
48854 wxStdDialogButtonSizer *result = 0 ;
48855
48856 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48857 {
48858 PyThreadState* __tstate = wxPyBeginAllowThreads();
48859 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48860 wxPyEndAllowThreads(__tstate);
48861 if (PyErr_Occurred()) SWIG_fail;
48862 }
48863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48864 return resultobj;
48865 fail:
48866 return NULL;
48867 }
48868
48869
48870 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48871 PyObject *resultobj = 0;
48872 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48873 wxButton *arg2 = (wxButton *) 0 ;
48874 void *argp1 = 0 ;
48875 int res1 = 0 ;
48876 void *argp2 = 0 ;
48877 int res2 = 0 ;
48878 PyObject * obj0 = 0 ;
48879 PyObject * obj1 = 0 ;
48880 char * kwnames[] = {
48881 (char *) "self",(char *) "button", NULL
48882 };
48883
48884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48886 if (!SWIG_IsOK(res1)) {
48887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48888 }
48889 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48891 if (!SWIG_IsOK(res2)) {
48892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48893 }
48894 arg2 = reinterpret_cast< wxButton * >(argp2);
48895 {
48896 PyThreadState* __tstate = wxPyBeginAllowThreads();
48897 (arg1)->AddButton(arg2);
48898 wxPyEndAllowThreads(__tstate);
48899 if (PyErr_Occurred()) SWIG_fail;
48900 }
48901 resultobj = SWIG_Py_Void();
48902 return resultobj;
48903 fail:
48904 return NULL;
48905 }
48906
48907
48908 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48909 PyObject *resultobj = 0;
48910 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48911 void *argp1 = 0 ;
48912 int res1 = 0 ;
48913 PyObject *swig_obj[1] ;
48914
48915 if (!args) SWIG_fail;
48916 swig_obj[0] = args;
48917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48918 if (!SWIG_IsOK(res1)) {
48919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48920 }
48921 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48922 {
48923 PyThreadState* __tstate = wxPyBeginAllowThreads();
48924 (arg1)->Realize();
48925 wxPyEndAllowThreads(__tstate);
48926 if (PyErr_Occurred()) SWIG_fail;
48927 }
48928 resultobj = SWIG_Py_Void();
48929 return resultobj;
48930 fail:
48931 return NULL;
48932 }
48933
48934
48935 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48936 PyObject *resultobj = 0;
48937 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48938 wxButton *arg2 = (wxButton *) 0 ;
48939 void *argp1 = 0 ;
48940 int res1 = 0 ;
48941 void *argp2 = 0 ;
48942 int res2 = 0 ;
48943 PyObject * obj0 = 0 ;
48944 PyObject * obj1 = 0 ;
48945 char * kwnames[] = {
48946 (char *) "self",(char *) "button", NULL
48947 };
48948
48949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48951 if (!SWIG_IsOK(res1)) {
48952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48953 }
48954 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48956 if (!SWIG_IsOK(res2)) {
48957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48958 }
48959 arg2 = reinterpret_cast< wxButton * >(argp2);
48960 {
48961 PyThreadState* __tstate = wxPyBeginAllowThreads();
48962 (arg1)->SetAffirmativeButton(arg2);
48963 wxPyEndAllowThreads(__tstate);
48964 if (PyErr_Occurred()) SWIG_fail;
48965 }
48966 resultobj = SWIG_Py_Void();
48967 return resultobj;
48968 fail:
48969 return NULL;
48970 }
48971
48972
48973 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48974 PyObject *resultobj = 0;
48975 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48976 wxButton *arg2 = (wxButton *) 0 ;
48977 void *argp1 = 0 ;
48978 int res1 = 0 ;
48979 void *argp2 = 0 ;
48980 int res2 = 0 ;
48981 PyObject * obj0 = 0 ;
48982 PyObject * obj1 = 0 ;
48983 char * kwnames[] = {
48984 (char *) "self",(char *) "button", NULL
48985 };
48986
48987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48989 if (!SWIG_IsOK(res1)) {
48990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48991 }
48992 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48994 if (!SWIG_IsOK(res2)) {
48995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48996 }
48997 arg2 = reinterpret_cast< wxButton * >(argp2);
48998 {
48999 PyThreadState* __tstate = wxPyBeginAllowThreads();
49000 (arg1)->SetNegativeButton(arg2);
49001 wxPyEndAllowThreads(__tstate);
49002 if (PyErr_Occurred()) SWIG_fail;
49003 }
49004 resultobj = SWIG_Py_Void();
49005 return resultobj;
49006 fail:
49007 return NULL;
49008 }
49009
49010
49011 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49012 PyObject *resultobj = 0;
49013 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49014 wxButton *arg2 = (wxButton *) 0 ;
49015 void *argp1 = 0 ;
49016 int res1 = 0 ;
49017 void *argp2 = 0 ;
49018 int res2 = 0 ;
49019 PyObject * obj0 = 0 ;
49020 PyObject * obj1 = 0 ;
49021 char * kwnames[] = {
49022 (char *) "self",(char *) "button", NULL
49023 };
49024
49025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49027 if (!SWIG_IsOK(res1)) {
49028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49029 }
49030 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49032 if (!SWIG_IsOK(res2)) {
49033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49034 }
49035 arg2 = reinterpret_cast< wxButton * >(argp2);
49036 {
49037 PyThreadState* __tstate = wxPyBeginAllowThreads();
49038 (arg1)->SetCancelButton(arg2);
49039 wxPyEndAllowThreads(__tstate);
49040 if (PyErr_Occurred()) SWIG_fail;
49041 }
49042 resultobj = SWIG_Py_Void();
49043 return resultobj;
49044 fail:
49045 return NULL;
49046 }
49047
49048
49049 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49050 PyObject *resultobj = 0;
49051 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49052 wxButton *result = 0 ;
49053 void *argp1 = 0 ;
49054 int res1 = 0 ;
49055 PyObject *swig_obj[1] ;
49056
49057 if (!args) SWIG_fail;
49058 swig_obj[0] = args;
49059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49060 if (!SWIG_IsOK(res1)) {
49061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49062 }
49063 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49064 {
49065 PyThreadState* __tstate = wxPyBeginAllowThreads();
49066 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49067 wxPyEndAllowThreads(__tstate);
49068 if (PyErr_Occurred()) SWIG_fail;
49069 }
49070 {
49071 resultobj = wxPyMake_wxObject(result, (bool)0);
49072 }
49073 return resultobj;
49074 fail:
49075 return NULL;
49076 }
49077
49078
49079 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49080 PyObject *resultobj = 0;
49081 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49082 wxButton *result = 0 ;
49083 void *argp1 = 0 ;
49084 int res1 = 0 ;
49085 PyObject *swig_obj[1] ;
49086
49087 if (!args) SWIG_fail;
49088 swig_obj[0] = args;
49089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49090 if (!SWIG_IsOK(res1)) {
49091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49092 }
49093 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49094 {
49095 PyThreadState* __tstate = wxPyBeginAllowThreads();
49096 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49097 wxPyEndAllowThreads(__tstate);
49098 if (PyErr_Occurred()) SWIG_fail;
49099 }
49100 {
49101 resultobj = wxPyMake_wxObject(result, (bool)0);
49102 }
49103 return resultobj;
49104 fail:
49105 return NULL;
49106 }
49107
49108
49109 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49110 PyObject *resultobj = 0;
49111 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49112 wxButton *result = 0 ;
49113 void *argp1 = 0 ;
49114 int res1 = 0 ;
49115 PyObject *swig_obj[1] ;
49116
49117 if (!args) SWIG_fail;
49118 swig_obj[0] = args;
49119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49120 if (!SWIG_IsOK(res1)) {
49121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49122 }
49123 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49124 {
49125 PyThreadState* __tstate = wxPyBeginAllowThreads();
49126 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49127 wxPyEndAllowThreads(__tstate);
49128 if (PyErr_Occurred()) SWIG_fail;
49129 }
49130 {
49131 resultobj = wxPyMake_wxObject(result, (bool)0);
49132 }
49133 return resultobj;
49134 fail:
49135 return NULL;
49136 }
49137
49138
49139 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49140 PyObject *resultobj = 0;
49141 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49142 wxButton *result = 0 ;
49143 void *argp1 = 0 ;
49144 int res1 = 0 ;
49145 PyObject *swig_obj[1] ;
49146
49147 if (!args) SWIG_fail;
49148 swig_obj[0] = args;
49149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49150 if (!SWIG_IsOK(res1)) {
49151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49152 }
49153 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49154 {
49155 PyThreadState* __tstate = wxPyBeginAllowThreads();
49156 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49157 wxPyEndAllowThreads(__tstate);
49158 if (PyErr_Occurred()) SWIG_fail;
49159 }
49160 {
49161 resultobj = wxPyMake_wxObject(result, (bool)0);
49162 }
49163 return resultobj;
49164 fail:
49165 return NULL;
49166 }
49167
49168
49169 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49170 PyObject *resultobj = 0;
49171 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49172 wxButton *result = 0 ;
49173 void *argp1 = 0 ;
49174 int res1 = 0 ;
49175 PyObject *swig_obj[1] ;
49176
49177 if (!args) SWIG_fail;
49178 swig_obj[0] = args;
49179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49180 if (!SWIG_IsOK(res1)) {
49181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49182 }
49183 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49184 {
49185 PyThreadState* __tstate = wxPyBeginAllowThreads();
49186 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49187 wxPyEndAllowThreads(__tstate);
49188 if (PyErr_Occurred()) SWIG_fail;
49189 }
49190 {
49191 resultobj = wxPyMake_wxObject(result, (bool)0);
49192 }
49193 return resultobj;
49194 fail:
49195 return NULL;
49196 }
49197
49198
49199 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49200 PyObject *obj;
49201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49202 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49203 return SWIG_Py_Void();
49204 }
49205
49206 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49207 return SWIG_Python_InitShadowInstance(args);
49208 }
49209
49210 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49211 PyObject *resultobj = 0;
49212 int arg1 = (int) 0 ;
49213 int arg2 = (int) 0 ;
49214 wxGBPosition *result = 0 ;
49215 int val1 ;
49216 int ecode1 = 0 ;
49217 int val2 ;
49218 int ecode2 = 0 ;
49219 PyObject * obj0 = 0 ;
49220 PyObject * obj1 = 0 ;
49221 char * kwnames[] = {
49222 (char *) "row",(char *) "col", NULL
49223 };
49224
49225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49226 if (obj0) {
49227 ecode1 = SWIG_AsVal_int(obj0, &val1);
49228 if (!SWIG_IsOK(ecode1)) {
49229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49230 }
49231 arg1 = static_cast< int >(val1);
49232 }
49233 if (obj1) {
49234 ecode2 = SWIG_AsVal_int(obj1, &val2);
49235 if (!SWIG_IsOK(ecode2)) {
49236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49237 }
49238 arg2 = static_cast< int >(val2);
49239 }
49240 {
49241 PyThreadState* __tstate = wxPyBeginAllowThreads();
49242 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49243 wxPyEndAllowThreads(__tstate);
49244 if (PyErr_Occurred()) SWIG_fail;
49245 }
49246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49247 return resultobj;
49248 fail:
49249 return NULL;
49250 }
49251
49252
49253 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49254 PyObject *resultobj = 0;
49255 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49256 void *argp1 = 0 ;
49257 int res1 = 0 ;
49258 PyObject *swig_obj[1] ;
49259
49260 if (!args) SWIG_fail;
49261 swig_obj[0] = args;
49262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49263 if (!SWIG_IsOK(res1)) {
49264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49265 }
49266 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49267 {
49268 PyThreadState* __tstate = wxPyBeginAllowThreads();
49269 delete arg1;
49270
49271 wxPyEndAllowThreads(__tstate);
49272 if (PyErr_Occurred()) SWIG_fail;
49273 }
49274 resultobj = SWIG_Py_Void();
49275 return resultobj;
49276 fail:
49277 return NULL;
49278 }
49279
49280
49281 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49282 PyObject *resultobj = 0;
49283 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49284 int result;
49285 void *argp1 = 0 ;
49286 int res1 = 0 ;
49287 PyObject *swig_obj[1] ;
49288
49289 if (!args) SWIG_fail;
49290 swig_obj[0] = args;
49291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49292 if (!SWIG_IsOK(res1)) {
49293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49294 }
49295 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49296 {
49297 PyThreadState* __tstate = wxPyBeginAllowThreads();
49298 result = (int)((wxGBPosition const *)arg1)->GetRow();
49299 wxPyEndAllowThreads(__tstate);
49300 if (PyErr_Occurred()) SWIG_fail;
49301 }
49302 resultobj = SWIG_From_int(static_cast< int >(result));
49303 return resultobj;
49304 fail:
49305 return NULL;
49306 }
49307
49308
49309 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49310 PyObject *resultobj = 0;
49311 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49312 int result;
49313 void *argp1 = 0 ;
49314 int res1 = 0 ;
49315 PyObject *swig_obj[1] ;
49316
49317 if (!args) SWIG_fail;
49318 swig_obj[0] = args;
49319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49320 if (!SWIG_IsOK(res1)) {
49321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49322 }
49323 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49324 {
49325 PyThreadState* __tstate = wxPyBeginAllowThreads();
49326 result = (int)((wxGBPosition const *)arg1)->GetCol();
49327 wxPyEndAllowThreads(__tstate);
49328 if (PyErr_Occurred()) SWIG_fail;
49329 }
49330 resultobj = SWIG_From_int(static_cast< int >(result));
49331 return resultobj;
49332 fail:
49333 return NULL;
49334 }
49335
49336
49337 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49338 PyObject *resultobj = 0;
49339 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49340 int arg2 ;
49341 void *argp1 = 0 ;
49342 int res1 = 0 ;
49343 int val2 ;
49344 int ecode2 = 0 ;
49345 PyObject * obj0 = 0 ;
49346 PyObject * obj1 = 0 ;
49347 char * kwnames[] = {
49348 (char *) "self",(char *) "row", NULL
49349 };
49350
49351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49353 if (!SWIG_IsOK(res1)) {
49354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49355 }
49356 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49357 ecode2 = SWIG_AsVal_int(obj1, &val2);
49358 if (!SWIG_IsOK(ecode2)) {
49359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49360 }
49361 arg2 = static_cast< int >(val2);
49362 {
49363 PyThreadState* __tstate = wxPyBeginAllowThreads();
49364 (arg1)->SetRow(arg2);
49365 wxPyEndAllowThreads(__tstate);
49366 if (PyErr_Occurred()) SWIG_fail;
49367 }
49368 resultobj = SWIG_Py_Void();
49369 return resultobj;
49370 fail:
49371 return NULL;
49372 }
49373
49374
49375 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49376 PyObject *resultobj = 0;
49377 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49378 int arg2 ;
49379 void *argp1 = 0 ;
49380 int res1 = 0 ;
49381 int val2 ;
49382 int ecode2 = 0 ;
49383 PyObject * obj0 = 0 ;
49384 PyObject * obj1 = 0 ;
49385 char * kwnames[] = {
49386 (char *) "self",(char *) "col", NULL
49387 };
49388
49389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49391 if (!SWIG_IsOK(res1)) {
49392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49393 }
49394 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49395 ecode2 = SWIG_AsVal_int(obj1, &val2);
49396 if (!SWIG_IsOK(ecode2)) {
49397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49398 }
49399 arg2 = static_cast< int >(val2);
49400 {
49401 PyThreadState* __tstate = wxPyBeginAllowThreads();
49402 (arg1)->SetCol(arg2);
49403 wxPyEndAllowThreads(__tstate);
49404 if (PyErr_Occurred()) SWIG_fail;
49405 }
49406 resultobj = SWIG_Py_Void();
49407 return resultobj;
49408 fail:
49409 return NULL;
49410 }
49411
49412
49413 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49414 PyObject *resultobj = 0;
49415 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49416 PyObject *arg2 = (PyObject *) 0 ;
49417 bool result;
49418 void *argp1 = 0 ;
49419 int res1 = 0 ;
49420 PyObject * obj0 = 0 ;
49421 PyObject * obj1 = 0 ;
49422 char * kwnames[] = {
49423 (char *) "self",(char *) "other", NULL
49424 };
49425
49426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49428 if (!SWIG_IsOK(res1)) {
49429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49430 }
49431 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49432 arg2 = obj1;
49433 {
49434 result = (bool)wxGBPosition___eq__(arg1,arg2);
49435 if (PyErr_Occurred()) SWIG_fail;
49436 }
49437 {
49438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49439 }
49440 return resultobj;
49441 fail:
49442 return NULL;
49443 }
49444
49445
49446 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49447 PyObject *resultobj = 0;
49448 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49449 PyObject *arg2 = (PyObject *) 0 ;
49450 bool result;
49451 void *argp1 = 0 ;
49452 int res1 = 0 ;
49453 PyObject * obj0 = 0 ;
49454 PyObject * obj1 = 0 ;
49455 char * kwnames[] = {
49456 (char *) "self",(char *) "other", NULL
49457 };
49458
49459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49461 if (!SWIG_IsOK(res1)) {
49462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49463 }
49464 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49465 arg2 = obj1;
49466 {
49467 result = (bool)wxGBPosition___ne__(arg1,arg2);
49468 if (PyErr_Occurred()) SWIG_fail;
49469 }
49470 {
49471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49472 }
49473 return resultobj;
49474 fail:
49475 return NULL;
49476 }
49477
49478
49479 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49480 PyObject *resultobj = 0;
49481 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49482 int arg2 = (int) 0 ;
49483 int arg3 = (int) 0 ;
49484 void *argp1 = 0 ;
49485 int res1 = 0 ;
49486 int val2 ;
49487 int ecode2 = 0 ;
49488 int val3 ;
49489 int ecode3 = 0 ;
49490 PyObject * obj0 = 0 ;
49491 PyObject * obj1 = 0 ;
49492 PyObject * obj2 = 0 ;
49493 char * kwnames[] = {
49494 (char *) "self",(char *) "row",(char *) "col", NULL
49495 };
49496
49497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49499 if (!SWIG_IsOK(res1)) {
49500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49501 }
49502 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49503 if (obj1) {
49504 ecode2 = SWIG_AsVal_int(obj1, &val2);
49505 if (!SWIG_IsOK(ecode2)) {
49506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49507 }
49508 arg2 = static_cast< int >(val2);
49509 }
49510 if (obj2) {
49511 ecode3 = SWIG_AsVal_int(obj2, &val3);
49512 if (!SWIG_IsOK(ecode3)) {
49513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49514 }
49515 arg3 = static_cast< int >(val3);
49516 }
49517 {
49518 PyThreadState* __tstate = wxPyBeginAllowThreads();
49519 wxGBPosition_Set(arg1,arg2,arg3);
49520 wxPyEndAllowThreads(__tstate);
49521 if (PyErr_Occurred()) SWIG_fail;
49522 }
49523 resultobj = SWIG_Py_Void();
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49531 PyObject *resultobj = 0;
49532 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49533 PyObject *result = 0 ;
49534 void *argp1 = 0 ;
49535 int res1 = 0 ;
49536 PyObject *swig_obj[1] ;
49537
49538 if (!args) SWIG_fail;
49539 swig_obj[0] = args;
49540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49541 if (!SWIG_IsOK(res1)) {
49542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49543 }
49544 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49545 {
49546 PyThreadState* __tstate = wxPyBeginAllowThreads();
49547 result = (PyObject *)wxGBPosition_Get(arg1);
49548 wxPyEndAllowThreads(__tstate);
49549 if (PyErr_Occurred()) SWIG_fail;
49550 }
49551 resultobj = result;
49552 return resultobj;
49553 fail:
49554 return NULL;
49555 }
49556
49557
49558 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49559 PyObject *obj;
49560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49561 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49562 return SWIG_Py_Void();
49563 }
49564
49565 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49566 return SWIG_Python_InitShadowInstance(args);
49567 }
49568
49569 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49570 PyObject *resultobj = 0;
49571 int arg1 = (int) 1 ;
49572 int arg2 = (int) 1 ;
49573 wxGBSpan *result = 0 ;
49574 int val1 ;
49575 int ecode1 = 0 ;
49576 int val2 ;
49577 int ecode2 = 0 ;
49578 PyObject * obj0 = 0 ;
49579 PyObject * obj1 = 0 ;
49580 char * kwnames[] = {
49581 (char *) "rowspan",(char *) "colspan", NULL
49582 };
49583
49584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49585 if (obj0) {
49586 ecode1 = SWIG_AsVal_int(obj0, &val1);
49587 if (!SWIG_IsOK(ecode1)) {
49588 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49589 }
49590 arg1 = static_cast< int >(val1);
49591 }
49592 if (obj1) {
49593 ecode2 = SWIG_AsVal_int(obj1, &val2);
49594 if (!SWIG_IsOK(ecode2)) {
49595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49596 }
49597 arg2 = static_cast< int >(val2);
49598 }
49599 {
49600 PyThreadState* __tstate = wxPyBeginAllowThreads();
49601 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49602 wxPyEndAllowThreads(__tstate);
49603 if (PyErr_Occurred()) SWIG_fail;
49604 }
49605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49606 return resultobj;
49607 fail:
49608 return NULL;
49609 }
49610
49611
49612 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49613 PyObject *resultobj = 0;
49614 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49615 void *argp1 = 0 ;
49616 int res1 = 0 ;
49617 PyObject *swig_obj[1] ;
49618
49619 if (!args) SWIG_fail;
49620 swig_obj[0] = args;
49621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49622 if (!SWIG_IsOK(res1)) {
49623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49624 }
49625 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49626 {
49627 PyThreadState* __tstate = wxPyBeginAllowThreads();
49628 delete arg1;
49629
49630 wxPyEndAllowThreads(__tstate);
49631 if (PyErr_Occurred()) SWIG_fail;
49632 }
49633 resultobj = SWIG_Py_Void();
49634 return resultobj;
49635 fail:
49636 return NULL;
49637 }
49638
49639
49640 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49641 PyObject *resultobj = 0;
49642 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49643 int result;
49644 void *argp1 = 0 ;
49645 int res1 = 0 ;
49646 PyObject *swig_obj[1] ;
49647
49648 if (!args) SWIG_fail;
49649 swig_obj[0] = args;
49650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49651 if (!SWIG_IsOK(res1)) {
49652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49653 }
49654 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49658 wxPyEndAllowThreads(__tstate);
49659 if (PyErr_Occurred()) SWIG_fail;
49660 }
49661 resultobj = SWIG_From_int(static_cast< int >(result));
49662 return resultobj;
49663 fail:
49664 return NULL;
49665 }
49666
49667
49668 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49669 PyObject *resultobj = 0;
49670 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49671 int result;
49672 void *argp1 = 0 ;
49673 int res1 = 0 ;
49674 PyObject *swig_obj[1] ;
49675
49676 if (!args) SWIG_fail;
49677 swig_obj[0] = args;
49678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49679 if (!SWIG_IsOK(res1)) {
49680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49681 }
49682 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49683 {
49684 PyThreadState* __tstate = wxPyBeginAllowThreads();
49685 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49686 wxPyEndAllowThreads(__tstate);
49687 if (PyErr_Occurred()) SWIG_fail;
49688 }
49689 resultobj = SWIG_From_int(static_cast< int >(result));
49690 return resultobj;
49691 fail:
49692 return NULL;
49693 }
49694
49695
49696 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49697 PyObject *resultobj = 0;
49698 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49699 int arg2 ;
49700 void *argp1 = 0 ;
49701 int res1 = 0 ;
49702 int val2 ;
49703 int ecode2 = 0 ;
49704 PyObject * obj0 = 0 ;
49705 PyObject * obj1 = 0 ;
49706 char * kwnames[] = {
49707 (char *) "self",(char *) "rowspan", NULL
49708 };
49709
49710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49712 if (!SWIG_IsOK(res1)) {
49713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49714 }
49715 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49716 ecode2 = SWIG_AsVal_int(obj1, &val2);
49717 if (!SWIG_IsOK(ecode2)) {
49718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49719 }
49720 arg2 = static_cast< int >(val2);
49721 {
49722 PyThreadState* __tstate = wxPyBeginAllowThreads();
49723 (arg1)->SetRowspan(arg2);
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 resultobj = SWIG_Py_Void();
49728 return resultobj;
49729 fail:
49730 return NULL;
49731 }
49732
49733
49734 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49735 PyObject *resultobj = 0;
49736 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49737 int arg2 ;
49738 void *argp1 = 0 ;
49739 int res1 = 0 ;
49740 int val2 ;
49741 int ecode2 = 0 ;
49742 PyObject * obj0 = 0 ;
49743 PyObject * obj1 = 0 ;
49744 char * kwnames[] = {
49745 (char *) "self",(char *) "colspan", NULL
49746 };
49747
49748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49750 if (!SWIG_IsOK(res1)) {
49751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49752 }
49753 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49754 ecode2 = SWIG_AsVal_int(obj1, &val2);
49755 if (!SWIG_IsOK(ecode2)) {
49756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49757 }
49758 arg2 = static_cast< int >(val2);
49759 {
49760 PyThreadState* __tstate = wxPyBeginAllowThreads();
49761 (arg1)->SetColspan(arg2);
49762 wxPyEndAllowThreads(__tstate);
49763 if (PyErr_Occurred()) SWIG_fail;
49764 }
49765 resultobj = SWIG_Py_Void();
49766 return resultobj;
49767 fail:
49768 return NULL;
49769 }
49770
49771
49772 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49773 PyObject *resultobj = 0;
49774 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49775 PyObject *arg2 = (PyObject *) 0 ;
49776 bool result;
49777 void *argp1 = 0 ;
49778 int res1 = 0 ;
49779 PyObject * obj0 = 0 ;
49780 PyObject * obj1 = 0 ;
49781 char * kwnames[] = {
49782 (char *) "self",(char *) "other", NULL
49783 };
49784
49785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49787 if (!SWIG_IsOK(res1)) {
49788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49789 }
49790 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49791 arg2 = obj1;
49792 {
49793 result = (bool)wxGBSpan___eq__(arg1,arg2);
49794 if (PyErr_Occurred()) SWIG_fail;
49795 }
49796 {
49797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49798 }
49799 return resultobj;
49800 fail:
49801 return NULL;
49802 }
49803
49804
49805 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49806 PyObject *resultobj = 0;
49807 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49808 PyObject *arg2 = (PyObject *) 0 ;
49809 bool result;
49810 void *argp1 = 0 ;
49811 int res1 = 0 ;
49812 PyObject * obj0 = 0 ;
49813 PyObject * obj1 = 0 ;
49814 char * kwnames[] = {
49815 (char *) "self",(char *) "other", NULL
49816 };
49817
49818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49820 if (!SWIG_IsOK(res1)) {
49821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49822 }
49823 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49824 arg2 = obj1;
49825 {
49826 result = (bool)wxGBSpan___ne__(arg1,arg2);
49827 if (PyErr_Occurred()) SWIG_fail;
49828 }
49829 {
49830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49831 }
49832 return resultobj;
49833 fail:
49834 return NULL;
49835 }
49836
49837
49838 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49839 PyObject *resultobj = 0;
49840 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49841 int arg2 = (int) 1 ;
49842 int arg3 = (int) 1 ;
49843 void *argp1 = 0 ;
49844 int res1 = 0 ;
49845 int val2 ;
49846 int ecode2 = 0 ;
49847 int val3 ;
49848 int ecode3 = 0 ;
49849 PyObject * obj0 = 0 ;
49850 PyObject * obj1 = 0 ;
49851 PyObject * obj2 = 0 ;
49852 char * kwnames[] = {
49853 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49854 };
49855
49856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49858 if (!SWIG_IsOK(res1)) {
49859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49860 }
49861 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49862 if (obj1) {
49863 ecode2 = SWIG_AsVal_int(obj1, &val2);
49864 if (!SWIG_IsOK(ecode2)) {
49865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49866 }
49867 arg2 = static_cast< int >(val2);
49868 }
49869 if (obj2) {
49870 ecode3 = SWIG_AsVal_int(obj2, &val3);
49871 if (!SWIG_IsOK(ecode3)) {
49872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49873 }
49874 arg3 = static_cast< int >(val3);
49875 }
49876 {
49877 PyThreadState* __tstate = wxPyBeginAllowThreads();
49878 wxGBSpan_Set(arg1,arg2,arg3);
49879 wxPyEndAllowThreads(__tstate);
49880 if (PyErr_Occurred()) SWIG_fail;
49881 }
49882 resultobj = SWIG_Py_Void();
49883 return resultobj;
49884 fail:
49885 return NULL;
49886 }
49887
49888
49889 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49890 PyObject *resultobj = 0;
49891 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49892 PyObject *result = 0 ;
49893 void *argp1 = 0 ;
49894 int res1 = 0 ;
49895 PyObject *swig_obj[1] ;
49896
49897 if (!args) SWIG_fail;
49898 swig_obj[0] = args;
49899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49900 if (!SWIG_IsOK(res1)) {
49901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49902 }
49903 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49904 {
49905 PyThreadState* __tstate = wxPyBeginAllowThreads();
49906 result = (PyObject *)wxGBSpan_Get(arg1);
49907 wxPyEndAllowThreads(__tstate);
49908 if (PyErr_Occurred()) SWIG_fail;
49909 }
49910 resultobj = result;
49911 return resultobj;
49912 fail:
49913 return NULL;
49914 }
49915
49916
49917 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49918 PyObject *obj;
49919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49920 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49921 return SWIG_Py_Void();
49922 }
49923
49924 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49925 return SWIG_Python_InitShadowInstance(args);
49926 }
49927
49928 SWIGINTERN int DefaultSpan_set(PyObject *) {
49929 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49930 return 1;
49931 }
49932
49933
49934 SWIGINTERN PyObject *DefaultSpan_get(void) {
49935 PyObject *pyobj = 0;
49936
49937 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49938 return pyobj;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49943 PyObject *resultobj = 0;
49944 wxGBSizerItem *result = 0 ;
49945
49946 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49947 {
49948 PyThreadState* __tstate = wxPyBeginAllowThreads();
49949 result = (wxGBSizerItem *)new wxGBSizerItem();
49950 wxPyEndAllowThreads(__tstate);
49951 if (PyErr_Occurred()) SWIG_fail;
49952 }
49953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49954 return resultobj;
49955 fail:
49956 return NULL;
49957 }
49958
49959
49960 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49961 PyObject *resultobj = 0;
49962 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49963 void *argp1 = 0 ;
49964 int res1 = 0 ;
49965 PyObject *swig_obj[1] ;
49966
49967 if (!args) SWIG_fail;
49968 swig_obj[0] = args;
49969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49970 if (!SWIG_IsOK(res1)) {
49971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49972 }
49973 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49974 {
49975 PyThreadState* __tstate = wxPyBeginAllowThreads();
49976 delete arg1;
49977
49978 wxPyEndAllowThreads(__tstate);
49979 if (PyErr_Occurred()) SWIG_fail;
49980 }
49981 resultobj = SWIG_Py_Void();
49982 return resultobj;
49983 fail:
49984 return NULL;
49985 }
49986
49987
49988 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49989 PyObject *resultobj = 0;
49990 wxWindow *arg1 = (wxWindow *) 0 ;
49991 wxGBPosition *arg2 = 0 ;
49992 wxGBSpan *arg3 = 0 ;
49993 int arg4 ;
49994 int arg5 ;
49995 PyObject *arg6 = (PyObject *) NULL ;
49996 wxGBSizerItem *result = 0 ;
49997 void *argp1 = 0 ;
49998 int res1 = 0 ;
49999 wxGBPosition temp2 ;
50000 wxGBSpan temp3 ;
50001 int val4 ;
50002 int ecode4 = 0 ;
50003 int val5 ;
50004 int ecode5 = 0 ;
50005 PyObject * obj0 = 0 ;
50006 PyObject * obj1 = 0 ;
50007 PyObject * obj2 = 0 ;
50008 PyObject * obj3 = 0 ;
50009 PyObject * obj4 = 0 ;
50010 PyObject * obj5 = 0 ;
50011 char * kwnames[] = {
50012 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50013 };
50014
50015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50017 if (!SWIG_IsOK(res1)) {
50018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50019 }
50020 arg1 = reinterpret_cast< wxWindow * >(argp1);
50021 {
50022 arg2 = &temp2;
50023 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50024 }
50025 {
50026 arg3 = &temp3;
50027 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50028 }
50029 ecode4 = SWIG_AsVal_int(obj3, &val4);
50030 if (!SWIG_IsOK(ecode4)) {
50031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50032 }
50033 arg4 = static_cast< int >(val4);
50034 ecode5 = SWIG_AsVal_int(obj4, &val5);
50035 if (!SWIG_IsOK(ecode5)) {
50036 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50037 }
50038 arg5 = static_cast< int >(val5);
50039 if (obj5) {
50040 arg6 = obj5;
50041 }
50042 {
50043 PyThreadState* __tstate = wxPyBeginAllowThreads();
50044 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50045 wxPyEndAllowThreads(__tstate);
50046 if (PyErr_Occurred()) SWIG_fail;
50047 }
50048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50049 return resultobj;
50050 fail:
50051 return NULL;
50052 }
50053
50054
50055 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50056 PyObject *resultobj = 0;
50057 wxSizer *arg1 = (wxSizer *) 0 ;
50058 wxGBPosition *arg2 = 0 ;
50059 wxGBSpan *arg3 = 0 ;
50060 int arg4 ;
50061 int arg5 ;
50062 PyObject *arg6 = (PyObject *) NULL ;
50063 wxGBSizerItem *result = 0 ;
50064 int res1 = 0 ;
50065 wxGBPosition temp2 ;
50066 wxGBSpan temp3 ;
50067 int val4 ;
50068 int ecode4 = 0 ;
50069 int val5 ;
50070 int ecode5 = 0 ;
50071 PyObject * obj0 = 0 ;
50072 PyObject * obj1 = 0 ;
50073 PyObject * obj2 = 0 ;
50074 PyObject * obj3 = 0 ;
50075 PyObject * obj4 = 0 ;
50076 PyObject * obj5 = 0 ;
50077 char * kwnames[] = {
50078 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50079 };
50080
50081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50082 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50083 if (!SWIG_IsOK(res1)) {
50084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50085 }
50086 {
50087 arg2 = &temp2;
50088 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50089 }
50090 {
50091 arg3 = &temp3;
50092 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50093 }
50094 ecode4 = SWIG_AsVal_int(obj3, &val4);
50095 if (!SWIG_IsOK(ecode4)) {
50096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50097 }
50098 arg4 = static_cast< int >(val4);
50099 ecode5 = SWIG_AsVal_int(obj4, &val5);
50100 if (!SWIG_IsOK(ecode5)) {
50101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50102 }
50103 arg5 = static_cast< int >(val5);
50104 if (obj5) {
50105 arg6 = obj5;
50106 }
50107 {
50108 PyThreadState* __tstate = wxPyBeginAllowThreads();
50109 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50110 wxPyEndAllowThreads(__tstate);
50111 if (PyErr_Occurred()) SWIG_fail;
50112 }
50113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50114 return resultobj;
50115 fail:
50116 return NULL;
50117 }
50118
50119
50120 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50121 PyObject *resultobj = 0;
50122 int arg1 ;
50123 int arg2 ;
50124 wxGBPosition *arg3 = 0 ;
50125 wxGBSpan *arg4 = 0 ;
50126 int arg5 ;
50127 int arg6 ;
50128 PyObject *arg7 = (PyObject *) NULL ;
50129 wxGBSizerItem *result = 0 ;
50130 int val1 ;
50131 int ecode1 = 0 ;
50132 int val2 ;
50133 int ecode2 = 0 ;
50134 wxGBPosition temp3 ;
50135 wxGBSpan temp4 ;
50136 int val5 ;
50137 int ecode5 = 0 ;
50138 int val6 ;
50139 int ecode6 = 0 ;
50140 PyObject * obj0 = 0 ;
50141 PyObject * obj1 = 0 ;
50142 PyObject * obj2 = 0 ;
50143 PyObject * obj3 = 0 ;
50144 PyObject * obj4 = 0 ;
50145 PyObject * obj5 = 0 ;
50146 PyObject * obj6 = 0 ;
50147 char * kwnames[] = {
50148 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50149 };
50150
50151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50152 ecode1 = SWIG_AsVal_int(obj0, &val1);
50153 if (!SWIG_IsOK(ecode1)) {
50154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50155 }
50156 arg1 = static_cast< int >(val1);
50157 ecode2 = SWIG_AsVal_int(obj1, &val2);
50158 if (!SWIG_IsOK(ecode2)) {
50159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50160 }
50161 arg2 = static_cast< int >(val2);
50162 {
50163 arg3 = &temp3;
50164 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50165 }
50166 {
50167 arg4 = &temp4;
50168 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50169 }
50170 ecode5 = SWIG_AsVal_int(obj4, &val5);
50171 if (!SWIG_IsOK(ecode5)) {
50172 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50173 }
50174 arg5 = static_cast< int >(val5);
50175 ecode6 = SWIG_AsVal_int(obj5, &val6);
50176 if (!SWIG_IsOK(ecode6)) {
50177 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50178 }
50179 arg6 = static_cast< int >(val6);
50180 if (obj6) {
50181 arg7 = obj6;
50182 }
50183 {
50184 PyThreadState* __tstate = wxPyBeginAllowThreads();
50185 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50186 wxPyEndAllowThreads(__tstate);
50187 if (PyErr_Occurred()) SWIG_fail;
50188 }
50189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50190 return resultobj;
50191 fail:
50192 return NULL;
50193 }
50194
50195
50196 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50197 PyObject *resultobj = 0;
50198 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50199 wxGBPosition result;
50200 void *argp1 = 0 ;
50201 int res1 = 0 ;
50202 PyObject *swig_obj[1] ;
50203
50204 if (!args) SWIG_fail;
50205 swig_obj[0] = args;
50206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50207 if (!SWIG_IsOK(res1)) {
50208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50209 }
50210 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50211 {
50212 PyThreadState* __tstate = wxPyBeginAllowThreads();
50213 result = ((wxGBSizerItem const *)arg1)->GetPos();
50214 wxPyEndAllowThreads(__tstate);
50215 if (PyErr_Occurred()) SWIG_fail;
50216 }
50217 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50218 return resultobj;
50219 fail:
50220 return NULL;
50221 }
50222
50223
50224 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50225 PyObject *resultobj = 0;
50226 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50227 wxGBSpan result;
50228 void *argp1 = 0 ;
50229 int res1 = 0 ;
50230 PyObject *swig_obj[1] ;
50231
50232 if (!args) SWIG_fail;
50233 swig_obj[0] = args;
50234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50235 if (!SWIG_IsOK(res1)) {
50236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50237 }
50238 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50239 {
50240 PyThreadState* __tstate = wxPyBeginAllowThreads();
50241 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50242 wxPyEndAllowThreads(__tstate);
50243 if (PyErr_Occurred()) SWIG_fail;
50244 }
50245 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50246 return resultobj;
50247 fail:
50248 return NULL;
50249 }
50250
50251
50252 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50253 PyObject *resultobj = 0;
50254 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50255 wxGBPosition *arg2 = 0 ;
50256 bool result;
50257 void *argp1 = 0 ;
50258 int res1 = 0 ;
50259 wxGBPosition temp2 ;
50260 PyObject * obj0 = 0 ;
50261 PyObject * obj1 = 0 ;
50262 char * kwnames[] = {
50263 (char *) "self",(char *) "pos", NULL
50264 };
50265
50266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50270 }
50271 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50272 {
50273 arg2 = &temp2;
50274 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50275 }
50276 {
50277 PyThreadState* __tstate = wxPyBeginAllowThreads();
50278 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50279 wxPyEndAllowThreads(__tstate);
50280 if (PyErr_Occurred()) SWIG_fail;
50281 }
50282 {
50283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50284 }
50285 return resultobj;
50286 fail:
50287 return NULL;
50288 }
50289
50290
50291 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50292 PyObject *resultobj = 0;
50293 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50294 wxGBSpan *arg2 = 0 ;
50295 bool result;
50296 void *argp1 = 0 ;
50297 int res1 = 0 ;
50298 wxGBSpan temp2 ;
50299 PyObject * obj0 = 0 ;
50300 PyObject * obj1 = 0 ;
50301 char * kwnames[] = {
50302 (char *) "self",(char *) "span", NULL
50303 };
50304
50305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50307 if (!SWIG_IsOK(res1)) {
50308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50309 }
50310 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50311 {
50312 arg2 = &temp2;
50313 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50314 }
50315 {
50316 PyThreadState* __tstate = wxPyBeginAllowThreads();
50317 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50318 wxPyEndAllowThreads(__tstate);
50319 if (PyErr_Occurred()) SWIG_fail;
50320 }
50321 {
50322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50323 }
50324 return resultobj;
50325 fail:
50326 return NULL;
50327 }
50328
50329
50330 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50331 PyObject *resultobj = 0;
50332 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50333 wxGBSizerItem *arg2 = 0 ;
50334 bool result;
50335 void *argp1 = 0 ;
50336 int res1 = 0 ;
50337 void *argp2 = 0 ;
50338 int res2 = 0 ;
50339 PyObject * obj0 = 0 ;
50340 PyObject * obj1 = 0 ;
50341 char * kwnames[] = {
50342 (char *) "self",(char *) "other", NULL
50343 };
50344
50345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50347 if (!SWIG_IsOK(res1)) {
50348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50349 }
50350 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50352 if (!SWIG_IsOK(res2)) {
50353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50354 }
50355 if (!argp2) {
50356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50357 }
50358 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50359 {
50360 PyThreadState* __tstate = wxPyBeginAllowThreads();
50361 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50362 wxPyEndAllowThreads(__tstate);
50363 if (PyErr_Occurred()) SWIG_fail;
50364 }
50365 {
50366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50367 }
50368 return resultobj;
50369 fail:
50370 return NULL;
50371 }
50372
50373
50374 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50375 PyObject *resultobj = 0;
50376 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50377 wxGBPosition *arg2 = 0 ;
50378 wxGBSpan *arg3 = 0 ;
50379 bool result;
50380 void *argp1 = 0 ;
50381 int res1 = 0 ;
50382 wxGBPosition temp2 ;
50383 wxGBSpan temp3 ;
50384 PyObject * obj0 = 0 ;
50385 PyObject * obj1 = 0 ;
50386 PyObject * obj2 = 0 ;
50387 char * kwnames[] = {
50388 (char *) "self",(char *) "pos",(char *) "span", NULL
50389 };
50390
50391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50393 if (!SWIG_IsOK(res1)) {
50394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50395 }
50396 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50397 {
50398 arg2 = &temp2;
50399 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50400 }
50401 {
50402 arg3 = &temp3;
50403 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50404 }
50405 {
50406 PyThreadState* __tstate = wxPyBeginAllowThreads();
50407 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50408 wxPyEndAllowThreads(__tstate);
50409 if (PyErr_Occurred()) SWIG_fail;
50410 }
50411 {
50412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50413 }
50414 return resultobj;
50415 fail:
50416 return NULL;
50417 }
50418
50419
50420 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50421 PyObject *resultobj = 0;
50422 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50423 wxGBPosition result;
50424 void *argp1 = 0 ;
50425 int res1 = 0 ;
50426 PyObject *swig_obj[1] ;
50427
50428 if (!args) SWIG_fail;
50429 swig_obj[0] = args;
50430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50431 if (!SWIG_IsOK(res1)) {
50432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50433 }
50434 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50435 {
50436 PyThreadState* __tstate = wxPyBeginAllowThreads();
50437 result = wxGBSizerItem_GetEndPos(arg1);
50438 wxPyEndAllowThreads(__tstate);
50439 if (PyErr_Occurred()) SWIG_fail;
50440 }
50441 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50442 return resultobj;
50443 fail:
50444 return NULL;
50445 }
50446
50447
50448 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50449 PyObject *resultobj = 0;
50450 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50451 wxGridBagSizer *result = 0 ;
50452 void *argp1 = 0 ;
50453 int res1 = 0 ;
50454 PyObject *swig_obj[1] ;
50455
50456 if (!args) SWIG_fail;
50457 swig_obj[0] = args;
50458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50459 if (!SWIG_IsOK(res1)) {
50460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50461 }
50462 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50463 {
50464 PyThreadState* __tstate = wxPyBeginAllowThreads();
50465 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50466 wxPyEndAllowThreads(__tstate);
50467 if (PyErr_Occurred()) SWIG_fail;
50468 }
50469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50470 return resultobj;
50471 fail:
50472 return NULL;
50473 }
50474
50475
50476 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50477 PyObject *resultobj = 0;
50478 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50479 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50480 void *argp1 = 0 ;
50481 int res1 = 0 ;
50482 void *argp2 = 0 ;
50483 int res2 = 0 ;
50484 PyObject * obj0 = 0 ;
50485 PyObject * obj1 = 0 ;
50486 char * kwnames[] = {
50487 (char *) "self",(char *) "sizer", NULL
50488 };
50489
50490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50492 if (!SWIG_IsOK(res1)) {
50493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50494 }
50495 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50496 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50497 if (!SWIG_IsOK(res2)) {
50498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50499 }
50500 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50501 {
50502 PyThreadState* __tstate = wxPyBeginAllowThreads();
50503 (arg1)->SetGBSizer(arg2);
50504 wxPyEndAllowThreads(__tstate);
50505 if (PyErr_Occurred()) SWIG_fail;
50506 }
50507 resultobj = SWIG_Py_Void();
50508 return resultobj;
50509 fail:
50510 return NULL;
50511 }
50512
50513
50514 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50515 PyObject *obj;
50516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50517 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50518 return SWIG_Py_Void();
50519 }
50520
50521 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50522 return SWIG_Python_InitShadowInstance(args);
50523 }
50524
50525 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50526 PyObject *resultobj = 0;
50527 int arg1 = (int) 0 ;
50528 int arg2 = (int) 0 ;
50529 wxGridBagSizer *result = 0 ;
50530 int val1 ;
50531 int ecode1 = 0 ;
50532 int val2 ;
50533 int ecode2 = 0 ;
50534 PyObject * obj0 = 0 ;
50535 PyObject * obj1 = 0 ;
50536 char * kwnames[] = {
50537 (char *) "vgap",(char *) "hgap", NULL
50538 };
50539
50540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50541 if (obj0) {
50542 ecode1 = SWIG_AsVal_int(obj0, &val1);
50543 if (!SWIG_IsOK(ecode1)) {
50544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50545 }
50546 arg1 = static_cast< int >(val1);
50547 }
50548 if (obj1) {
50549 ecode2 = SWIG_AsVal_int(obj1, &val2);
50550 if (!SWIG_IsOK(ecode2)) {
50551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50552 }
50553 arg2 = static_cast< int >(val2);
50554 }
50555 {
50556 PyThreadState* __tstate = wxPyBeginAllowThreads();
50557 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50558 wxPyEndAllowThreads(__tstate);
50559 if (PyErr_Occurred()) SWIG_fail;
50560 }
50561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50562 return resultobj;
50563 fail:
50564 return NULL;
50565 }
50566
50567
50568 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50569 PyObject *resultobj = 0;
50570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50571 PyObject *arg2 = (PyObject *) 0 ;
50572 wxGBPosition *arg3 = 0 ;
50573 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50574 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50575 int arg5 = (int) 0 ;
50576 int arg6 = (int) 0 ;
50577 PyObject *arg7 = (PyObject *) NULL ;
50578 wxGBSizerItem *result = 0 ;
50579 void *argp1 = 0 ;
50580 int res1 = 0 ;
50581 wxGBPosition temp3 ;
50582 wxGBSpan temp4 ;
50583 int val5 ;
50584 int ecode5 = 0 ;
50585 int val6 ;
50586 int ecode6 = 0 ;
50587 PyObject * obj0 = 0 ;
50588 PyObject * obj1 = 0 ;
50589 PyObject * obj2 = 0 ;
50590 PyObject * obj3 = 0 ;
50591 PyObject * obj4 = 0 ;
50592 PyObject * obj5 = 0 ;
50593 PyObject * obj6 = 0 ;
50594 char * kwnames[] = {
50595 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50596 };
50597
50598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50600 if (!SWIG_IsOK(res1)) {
50601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50602 }
50603 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50604 arg2 = obj1;
50605 {
50606 arg3 = &temp3;
50607 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50608 }
50609 if (obj3) {
50610 {
50611 arg4 = &temp4;
50612 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50613 }
50614 }
50615 if (obj4) {
50616 ecode5 = SWIG_AsVal_int(obj4, &val5);
50617 if (!SWIG_IsOK(ecode5)) {
50618 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50619 }
50620 arg5 = static_cast< int >(val5);
50621 }
50622 if (obj5) {
50623 ecode6 = SWIG_AsVal_int(obj5, &val6);
50624 if (!SWIG_IsOK(ecode6)) {
50625 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50626 }
50627 arg6 = static_cast< int >(val6);
50628 }
50629 if (obj6) {
50630 arg7 = obj6;
50631 }
50632 {
50633 PyThreadState* __tstate = wxPyBeginAllowThreads();
50634 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50635 wxPyEndAllowThreads(__tstate);
50636 if (PyErr_Occurred()) SWIG_fail;
50637 }
50638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50639 return resultobj;
50640 fail:
50641 return NULL;
50642 }
50643
50644
50645 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50646 PyObject *resultobj = 0;
50647 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50648 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50649 wxGBSizerItem *result = 0 ;
50650 void *argp1 = 0 ;
50651 int res1 = 0 ;
50652 int res2 = 0 ;
50653 PyObject * obj0 = 0 ;
50654 PyObject * obj1 = 0 ;
50655 char * kwnames[] = {
50656 (char *) "self",(char *) "item", NULL
50657 };
50658
50659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50661 if (!SWIG_IsOK(res1)) {
50662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50663 }
50664 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50665 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50666 if (!SWIG_IsOK(res2)) {
50667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50668 }
50669 {
50670 PyThreadState* __tstate = wxPyBeginAllowThreads();
50671 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50672 wxPyEndAllowThreads(__tstate);
50673 if (PyErr_Occurred()) SWIG_fail;
50674 }
50675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50676 return resultobj;
50677 fail:
50678 return NULL;
50679 }
50680
50681
50682 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50683 PyObject *resultobj = 0;
50684 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50685 int arg2 ;
50686 int arg3 ;
50687 wxSize result;
50688 void *argp1 = 0 ;
50689 int res1 = 0 ;
50690 int val2 ;
50691 int ecode2 = 0 ;
50692 int val3 ;
50693 int ecode3 = 0 ;
50694 PyObject * obj0 = 0 ;
50695 PyObject * obj1 = 0 ;
50696 PyObject * obj2 = 0 ;
50697 char * kwnames[] = {
50698 (char *) "self",(char *) "row",(char *) "col", NULL
50699 };
50700
50701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50703 if (!SWIG_IsOK(res1)) {
50704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50705 }
50706 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50707 ecode2 = SWIG_AsVal_int(obj1, &val2);
50708 if (!SWIG_IsOK(ecode2)) {
50709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50710 }
50711 arg2 = static_cast< int >(val2);
50712 ecode3 = SWIG_AsVal_int(obj2, &val3);
50713 if (!SWIG_IsOK(ecode3)) {
50714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50715 }
50716 arg3 = static_cast< int >(val3);
50717 {
50718 PyThreadState* __tstate = wxPyBeginAllowThreads();
50719 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50720 wxPyEndAllowThreads(__tstate);
50721 if (PyErr_Occurred()) SWIG_fail;
50722 }
50723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50724 return resultobj;
50725 fail:
50726 return NULL;
50727 }
50728
50729
50730 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50731 PyObject *resultobj = 0;
50732 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50733 wxSize result;
50734 void *argp1 = 0 ;
50735 int res1 = 0 ;
50736 PyObject *swig_obj[1] ;
50737
50738 if (!args) SWIG_fail;
50739 swig_obj[0] = args;
50740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50741 if (!SWIG_IsOK(res1)) {
50742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50743 }
50744 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50745 {
50746 PyThreadState* __tstate = wxPyBeginAllowThreads();
50747 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50748 wxPyEndAllowThreads(__tstate);
50749 if (PyErr_Occurred()) SWIG_fail;
50750 }
50751 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50752 return resultobj;
50753 fail:
50754 return NULL;
50755 }
50756
50757
50758 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50759 PyObject *resultobj = 0;
50760 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50761 wxSize *arg2 = 0 ;
50762 void *argp1 = 0 ;
50763 int res1 = 0 ;
50764 wxSize temp2 ;
50765 PyObject * obj0 = 0 ;
50766 PyObject * obj1 = 0 ;
50767 char * kwnames[] = {
50768 (char *) "self",(char *) "sz", NULL
50769 };
50770
50771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50773 if (!SWIG_IsOK(res1)) {
50774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50775 }
50776 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50777 {
50778 arg2 = &temp2;
50779 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50780 }
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50784 wxPyEndAllowThreads(__tstate);
50785 if (PyErr_Occurred()) SWIG_fail;
50786 }
50787 resultobj = SWIG_Py_Void();
50788 return resultobj;
50789 fail:
50790 return NULL;
50791 }
50792
50793
50794 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50795 PyObject *resultobj = 0;
50796 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50797 wxWindow *arg2 = (wxWindow *) 0 ;
50798 wxGBPosition result;
50799 void *argp1 = 0 ;
50800 int res1 = 0 ;
50801 void *argp2 = 0 ;
50802 int res2 = 0 ;
50803
50804 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50806 if (!SWIG_IsOK(res1)) {
50807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50808 }
50809 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50810 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50811 if (!SWIG_IsOK(res2)) {
50812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50813 }
50814 arg2 = reinterpret_cast< wxWindow * >(argp2);
50815 {
50816 PyThreadState* __tstate = wxPyBeginAllowThreads();
50817 result = (arg1)->GetItemPosition(arg2);
50818 wxPyEndAllowThreads(__tstate);
50819 if (PyErr_Occurred()) SWIG_fail;
50820 }
50821 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50822 return resultobj;
50823 fail:
50824 return NULL;
50825 }
50826
50827
50828 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50829 PyObject *resultobj = 0;
50830 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50831 wxSizer *arg2 = (wxSizer *) 0 ;
50832 wxGBPosition result;
50833 void *argp1 = 0 ;
50834 int res1 = 0 ;
50835 void *argp2 = 0 ;
50836 int res2 = 0 ;
50837
50838 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50840 if (!SWIG_IsOK(res1)) {
50841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50842 }
50843 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50844 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50845 if (!SWIG_IsOK(res2)) {
50846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50847 }
50848 arg2 = reinterpret_cast< wxSizer * >(argp2);
50849 {
50850 PyThreadState* __tstate = wxPyBeginAllowThreads();
50851 result = (arg1)->GetItemPosition(arg2);
50852 wxPyEndAllowThreads(__tstate);
50853 if (PyErr_Occurred()) SWIG_fail;
50854 }
50855 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50856 return resultobj;
50857 fail:
50858 return NULL;
50859 }
50860
50861
50862 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50863 PyObject *resultobj = 0;
50864 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50865 size_t arg2 ;
50866 wxGBPosition result;
50867 void *argp1 = 0 ;
50868 int res1 = 0 ;
50869 size_t val2 ;
50870 int ecode2 = 0 ;
50871
50872 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50874 if (!SWIG_IsOK(res1)) {
50875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50876 }
50877 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50878 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50879 if (!SWIG_IsOK(ecode2)) {
50880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50881 }
50882 arg2 = static_cast< size_t >(val2);
50883 {
50884 PyThreadState* __tstate = wxPyBeginAllowThreads();
50885 result = (arg1)->GetItemPosition(arg2);
50886 wxPyEndAllowThreads(__tstate);
50887 if (PyErr_Occurred()) SWIG_fail;
50888 }
50889 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50890 return resultobj;
50891 fail:
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50897 int argc;
50898 PyObject *argv[3];
50899
50900 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50901 --argc;
50902 if (argc == 2) {
50903 int _v = 0;
50904 {
50905 void *vptr = 0;
50906 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50907 _v = SWIG_CheckState(res);
50908 }
50909 if (!_v) goto check_1;
50910 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50911 }
50912 check_1:
50913
50914 if (argc == 2) {
50915 int _v = 0;
50916 {
50917 void *vptr = 0;
50918 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50919 _v = SWIG_CheckState(res);
50920 }
50921 if (!_v) goto check_2;
50922 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50923 }
50924 check_2:
50925
50926 if (argc == 2) {
50927 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50928 }
50929
50930 fail:
50931 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50932 return NULL;
50933 }
50934
50935
50936 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50937 PyObject *resultobj = 0;
50938 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50939 wxWindow *arg2 = (wxWindow *) 0 ;
50940 wxGBPosition *arg3 = 0 ;
50941 bool result;
50942 void *argp1 = 0 ;
50943 int res1 = 0 ;
50944 void *argp2 = 0 ;
50945 int res2 = 0 ;
50946 wxGBPosition temp3 ;
50947
50948 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50950 if (!SWIG_IsOK(res1)) {
50951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50952 }
50953 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50954 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50955 if (!SWIG_IsOK(res2)) {
50956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50957 }
50958 arg2 = reinterpret_cast< wxWindow * >(argp2);
50959 {
50960 arg3 = &temp3;
50961 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50962 }
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 {
50970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50971 }
50972 return resultobj;
50973 fail:
50974 return NULL;
50975 }
50976
50977
50978 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50979 PyObject *resultobj = 0;
50980 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50981 wxSizer *arg2 = (wxSizer *) 0 ;
50982 wxGBPosition *arg3 = 0 ;
50983 bool result;
50984 void *argp1 = 0 ;
50985 int res1 = 0 ;
50986 void *argp2 = 0 ;
50987 int res2 = 0 ;
50988 wxGBPosition temp3 ;
50989
50990 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50992 if (!SWIG_IsOK(res1)) {
50993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50994 }
50995 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50996 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50997 if (!SWIG_IsOK(res2)) {
50998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50999 }
51000 arg2 = reinterpret_cast< wxSizer * >(argp2);
51001 {
51002 arg3 = &temp3;
51003 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51004 }
51005 {
51006 PyThreadState* __tstate = wxPyBeginAllowThreads();
51007 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51008 wxPyEndAllowThreads(__tstate);
51009 if (PyErr_Occurred()) SWIG_fail;
51010 }
51011 {
51012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51013 }
51014 return resultobj;
51015 fail:
51016 return NULL;
51017 }
51018
51019
51020 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51021 PyObject *resultobj = 0;
51022 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51023 size_t arg2 ;
51024 wxGBPosition *arg3 = 0 ;
51025 bool result;
51026 void *argp1 = 0 ;
51027 int res1 = 0 ;
51028 size_t val2 ;
51029 int ecode2 = 0 ;
51030 wxGBPosition temp3 ;
51031
51032 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51034 if (!SWIG_IsOK(res1)) {
51035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51036 }
51037 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51038 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51039 if (!SWIG_IsOK(ecode2)) {
51040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51041 }
51042 arg2 = static_cast< size_t >(val2);
51043 {
51044 arg3 = &temp3;
51045 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51046 }
51047 {
51048 PyThreadState* __tstate = wxPyBeginAllowThreads();
51049 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51050 wxPyEndAllowThreads(__tstate);
51051 if (PyErr_Occurred()) SWIG_fail;
51052 }
51053 {
51054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51055 }
51056 return resultobj;
51057 fail:
51058 return NULL;
51059 }
51060
51061
51062 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51063 int argc;
51064 PyObject *argv[4];
51065
51066 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51067 --argc;
51068 if (argc == 3) {
51069 int _v = 0;
51070 {
51071 void *vptr = 0;
51072 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51073 _v = SWIG_CheckState(res);
51074 }
51075 if (!_v) goto check_1;
51076 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51077 }
51078 check_1:
51079
51080 if (argc == 3) {
51081 int _v = 0;
51082 {
51083 void *vptr = 0;
51084 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51085 _v = SWIG_CheckState(res);
51086 }
51087 if (!_v) goto check_2;
51088 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51089 }
51090 check_2:
51091
51092 if (argc == 3) {
51093 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51094 }
51095
51096 fail:
51097 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51098 return NULL;
51099 }
51100
51101
51102 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51103 PyObject *resultobj = 0;
51104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51105 wxWindow *arg2 = (wxWindow *) 0 ;
51106 wxGBSpan result;
51107 void *argp1 = 0 ;
51108 int res1 = 0 ;
51109 void *argp2 = 0 ;
51110 int res2 = 0 ;
51111
51112 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51114 if (!SWIG_IsOK(res1)) {
51115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51116 }
51117 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51118 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51119 if (!SWIG_IsOK(res2)) {
51120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51121 }
51122 arg2 = reinterpret_cast< wxWindow * >(argp2);
51123 {
51124 PyThreadState* __tstate = wxPyBeginAllowThreads();
51125 result = (arg1)->GetItemSpan(arg2);
51126 wxPyEndAllowThreads(__tstate);
51127 if (PyErr_Occurred()) SWIG_fail;
51128 }
51129 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51130 return resultobj;
51131 fail:
51132 return NULL;
51133 }
51134
51135
51136 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51137 PyObject *resultobj = 0;
51138 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51139 wxSizer *arg2 = (wxSizer *) 0 ;
51140 wxGBSpan result;
51141 void *argp1 = 0 ;
51142 int res1 = 0 ;
51143 void *argp2 = 0 ;
51144 int res2 = 0 ;
51145
51146 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51148 if (!SWIG_IsOK(res1)) {
51149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51150 }
51151 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51152 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51153 if (!SWIG_IsOK(res2)) {
51154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51155 }
51156 arg2 = reinterpret_cast< wxSizer * >(argp2);
51157 {
51158 PyThreadState* __tstate = wxPyBeginAllowThreads();
51159 result = (arg1)->GetItemSpan(arg2);
51160 wxPyEndAllowThreads(__tstate);
51161 if (PyErr_Occurred()) SWIG_fail;
51162 }
51163 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51164 return resultobj;
51165 fail:
51166 return NULL;
51167 }
51168
51169
51170 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51171 PyObject *resultobj = 0;
51172 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51173 size_t arg2 ;
51174 wxGBSpan result;
51175 void *argp1 = 0 ;
51176 int res1 = 0 ;
51177 size_t val2 ;
51178 int ecode2 = 0 ;
51179
51180 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51182 if (!SWIG_IsOK(res1)) {
51183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51184 }
51185 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51186 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51187 if (!SWIG_IsOK(ecode2)) {
51188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51189 }
51190 arg2 = static_cast< size_t >(val2);
51191 {
51192 PyThreadState* __tstate = wxPyBeginAllowThreads();
51193 result = (arg1)->GetItemSpan(arg2);
51194 wxPyEndAllowThreads(__tstate);
51195 if (PyErr_Occurred()) SWIG_fail;
51196 }
51197 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51198 return resultobj;
51199 fail:
51200 return NULL;
51201 }
51202
51203
51204 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51205 int argc;
51206 PyObject *argv[3];
51207
51208 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51209 --argc;
51210 if (argc == 2) {
51211 int _v = 0;
51212 {
51213 void *vptr = 0;
51214 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51215 _v = SWIG_CheckState(res);
51216 }
51217 if (!_v) goto check_1;
51218 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51219 }
51220 check_1:
51221
51222 if (argc == 2) {
51223 int _v = 0;
51224 {
51225 void *vptr = 0;
51226 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51227 _v = SWIG_CheckState(res);
51228 }
51229 if (!_v) goto check_2;
51230 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51231 }
51232 check_2:
51233
51234 if (argc == 2) {
51235 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51236 }
51237
51238 fail:
51239 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51240 return NULL;
51241 }
51242
51243
51244 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51245 PyObject *resultobj = 0;
51246 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51247 wxWindow *arg2 = (wxWindow *) 0 ;
51248 wxGBSpan *arg3 = 0 ;
51249 bool result;
51250 void *argp1 = 0 ;
51251 int res1 = 0 ;
51252 void *argp2 = 0 ;
51253 int res2 = 0 ;
51254 wxGBSpan temp3 ;
51255
51256 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51258 if (!SWIG_IsOK(res1)) {
51259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51260 }
51261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51263 if (!SWIG_IsOK(res2)) {
51264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51265 }
51266 arg2 = reinterpret_cast< wxWindow * >(argp2);
51267 {
51268 arg3 = &temp3;
51269 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51270 }
51271 {
51272 PyThreadState* __tstate = wxPyBeginAllowThreads();
51273 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51274 wxPyEndAllowThreads(__tstate);
51275 if (PyErr_Occurred()) SWIG_fail;
51276 }
51277 {
51278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51279 }
51280 return resultobj;
51281 fail:
51282 return NULL;
51283 }
51284
51285
51286 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51287 PyObject *resultobj = 0;
51288 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51289 wxSizer *arg2 = (wxSizer *) 0 ;
51290 wxGBSpan *arg3 = 0 ;
51291 bool result;
51292 void *argp1 = 0 ;
51293 int res1 = 0 ;
51294 void *argp2 = 0 ;
51295 int res2 = 0 ;
51296 wxGBSpan temp3 ;
51297
51298 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51300 if (!SWIG_IsOK(res1)) {
51301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51302 }
51303 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51304 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51305 if (!SWIG_IsOK(res2)) {
51306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51307 }
51308 arg2 = reinterpret_cast< wxSizer * >(argp2);
51309 {
51310 arg3 = &temp3;
51311 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51312 }
51313 {
51314 PyThreadState* __tstate = wxPyBeginAllowThreads();
51315 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51316 wxPyEndAllowThreads(__tstate);
51317 if (PyErr_Occurred()) SWIG_fail;
51318 }
51319 {
51320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51321 }
51322 return resultobj;
51323 fail:
51324 return NULL;
51325 }
51326
51327
51328 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51329 PyObject *resultobj = 0;
51330 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51331 size_t arg2 ;
51332 wxGBSpan *arg3 = 0 ;
51333 bool result;
51334 void *argp1 = 0 ;
51335 int res1 = 0 ;
51336 size_t val2 ;
51337 int ecode2 = 0 ;
51338 wxGBSpan temp3 ;
51339
51340 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51342 if (!SWIG_IsOK(res1)) {
51343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51344 }
51345 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51346 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51347 if (!SWIG_IsOK(ecode2)) {
51348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51349 }
51350 arg2 = static_cast< size_t >(val2);
51351 {
51352 arg3 = &temp3;
51353 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51354 }
51355 {
51356 PyThreadState* __tstate = wxPyBeginAllowThreads();
51357 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51358 wxPyEndAllowThreads(__tstate);
51359 if (PyErr_Occurred()) SWIG_fail;
51360 }
51361 {
51362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51363 }
51364 return resultobj;
51365 fail:
51366 return NULL;
51367 }
51368
51369
51370 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51371 int argc;
51372 PyObject *argv[4];
51373
51374 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51375 --argc;
51376 if (argc == 3) {
51377 int _v = 0;
51378 {
51379 void *vptr = 0;
51380 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51381 _v = SWIG_CheckState(res);
51382 }
51383 if (!_v) goto check_1;
51384 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51385 }
51386 check_1:
51387
51388 if (argc == 3) {
51389 int _v = 0;
51390 {
51391 void *vptr = 0;
51392 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51393 _v = SWIG_CheckState(res);
51394 }
51395 if (!_v) goto check_2;
51396 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51397 }
51398 check_2:
51399
51400 if (argc == 3) {
51401 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51402 }
51403
51404 fail:
51405 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51406 return NULL;
51407 }
51408
51409
51410 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51411 PyObject *resultobj = 0;
51412 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51413 wxWindow *arg2 = (wxWindow *) 0 ;
51414 wxGBSizerItem *result = 0 ;
51415 void *argp1 = 0 ;
51416 int res1 = 0 ;
51417 void *argp2 = 0 ;
51418 int res2 = 0 ;
51419
51420 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51422 if (!SWIG_IsOK(res1)) {
51423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51424 }
51425 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51426 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51427 if (!SWIG_IsOK(res2)) {
51428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51429 }
51430 arg2 = reinterpret_cast< wxWindow * >(argp2);
51431 {
51432 PyThreadState* __tstate = wxPyBeginAllowThreads();
51433 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51434 wxPyEndAllowThreads(__tstate);
51435 if (PyErr_Occurred()) SWIG_fail;
51436 }
51437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51438 return resultobj;
51439 fail:
51440 return NULL;
51441 }
51442
51443
51444 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51445 PyObject *resultobj = 0;
51446 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51447 wxSizer *arg2 = (wxSizer *) 0 ;
51448 wxGBSizerItem *result = 0 ;
51449 void *argp1 = 0 ;
51450 int res1 = 0 ;
51451 void *argp2 = 0 ;
51452 int res2 = 0 ;
51453
51454 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51456 if (!SWIG_IsOK(res1)) {
51457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51458 }
51459 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51460 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51461 if (!SWIG_IsOK(res2)) {
51462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51463 }
51464 arg2 = reinterpret_cast< wxSizer * >(argp2);
51465 {
51466 PyThreadState* __tstate = wxPyBeginAllowThreads();
51467 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51468 wxPyEndAllowThreads(__tstate);
51469 if (PyErr_Occurred()) SWIG_fail;
51470 }
51471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51472 return resultobj;
51473 fail:
51474 return NULL;
51475 }
51476
51477
51478 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51479 int argc;
51480 PyObject *argv[3];
51481
51482 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51483 --argc;
51484 if (argc == 2) {
51485 int _v = 0;
51486 {
51487 void *vptr = 0;
51488 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51489 _v = SWIG_CheckState(res);
51490 }
51491 if (!_v) goto check_1;
51492 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51493 }
51494 check_1:
51495
51496 if (argc == 2) {
51497 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51498 }
51499
51500 fail:
51501 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51502 return NULL;
51503 }
51504
51505
51506 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51507 PyObject *resultobj = 0;
51508 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51509 wxGBPosition *arg2 = 0 ;
51510 wxGBSizerItem *result = 0 ;
51511 void *argp1 = 0 ;
51512 int res1 = 0 ;
51513 wxGBPosition temp2 ;
51514 PyObject * obj0 = 0 ;
51515 PyObject * obj1 = 0 ;
51516 char * kwnames[] = {
51517 (char *) "self",(char *) "pos", NULL
51518 };
51519
51520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51522 if (!SWIG_IsOK(res1)) {
51523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51524 }
51525 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51526 {
51527 arg2 = &temp2;
51528 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51529 }
51530 {
51531 PyThreadState* __tstate = wxPyBeginAllowThreads();
51532 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51533 wxPyEndAllowThreads(__tstate);
51534 if (PyErr_Occurred()) SWIG_fail;
51535 }
51536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51537 return resultobj;
51538 fail:
51539 return NULL;
51540 }
51541
51542
51543 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51544 PyObject *resultobj = 0;
51545 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51546 wxPoint *arg2 = 0 ;
51547 wxGBSizerItem *result = 0 ;
51548 void *argp1 = 0 ;
51549 int res1 = 0 ;
51550 wxPoint temp2 ;
51551 PyObject * obj0 = 0 ;
51552 PyObject * obj1 = 0 ;
51553 char * kwnames[] = {
51554 (char *) "self",(char *) "pt", NULL
51555 };
51556
51557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51559 if (!SWIG_IsOK(res1)) {
51560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51561 }
51562 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51563 {
51564 arg2 = &temp2;
51565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51566 }
51567 {
51568 PyThreadState* __tstate = wxPyBeginAllowThreads();
51569 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51570 wxPyEndAllowThreads(__tstate);
51571 if (PyErr_Occurred()) SWIG_fail;
51572 }
51573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51574 return resultobj;
51575 fail:
51576 return NULL;
51577 }
51578
51579
51580 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51581 PyObject *resultobj = 0;
51582 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51583 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51584 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51585 bool result;
51586 void *argp1 = 0 ;
51587 int res1 = 0 ;
51588 void *argp2 = 0 ;
51589 int res2 = 0 ;
51590 void *argp3 = 0 ;
51591 int res3 = 0 ;
51592 PyObject * obj0 = 0 ;
51593 PyObject * obj1 = 0 ;
51594 PyObject * obj2 = 0 ;
51595 char * kwnames[] = {
51596 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51597 };
51598
51599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51601 if (!SWIG_IsOK(res1)) {
51602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51603 }
51604 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51605 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51606 if (!SWIG_IsOK(res2)) {
51607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51608 }
51609 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51610 if (obj2) {
51611 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51612 if (!SWIG_IsOK(res3)) {
51613 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51614 }
51615 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51616 }
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 {
51624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51625 }
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51633 PyObject *resultobj = 0;
51634 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51635 wxGBPosition *arg2 = 0 ;
51636 wxGBSpan *arg3 = 0 ;
51637 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51638 bool result;
51639 void *argp1 = 0 ;
51640 int res1 = 0 ;
51641 wxGBPosition temp2 ;
51642 wxGBSpan temp3 ;
51643 void *argp4 = 0 ;
51644 int res4 = 0 ;
51645 PyObject * obj0 = 0 ;
51646 PyObject * obj1 = 0 ;
51647 PyObject * obj2 = 0 ;
51648 PyObject * obj3 = 0 ;
51649 char * kwnames[] = {
51650 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51651 };
51652
51653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51655 if (!SWIG_IsOK(res1)) {
51656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51657 }
51658 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51659 {
51660 arg2 = &temp2;
51661 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51662 }
51663 {
51664 arg3 = &temp3;
51665 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51666 }
51667 if (obj3) {
51668 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51669 if (!SWIG_IsOK(res4)) {
51670 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51671 }
51672 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51673 }
51674 {
51675 PyThreadState* __tstate = wxPyBeginAllowThreads();
51676 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51677 wxPyEndAllowThreads(__tstate);
51678 if (PyErr_Occurred()) SWIG_fail;
51679 }
51680 {
51681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51682 }
51683 return resultobj;
51684 fail:
51685 return NULL;
51686 }
51687
51688
51689 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51690 PyObject *obj;
51691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51692 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51693 return SWIG_Py_Void();
51694 }
51695
51696 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51697 return SWIG_Python_InitShadowInstance(args);
51698 }
51699
51700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51701 PyObject *resultobj = 0;
51702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51703 wxRelationship arg2 ;
51704 wxWindow *arg3 = (wxWindow *) 0 ;
51705 wxEdge arg4 ;
51706 int arg5 = (int) 0 ;
51707 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51708 void *argp1 = 0 ;
51709 int res1 = 0 ;
51710 int val2 ;
51711 int ecode2 = 0 ;
51712 void *argp3 = 0 ;
51713 int res3 = 0 ;
51714 int val4 ;
51715 int ecode4 = 0 ;
51716 int val5 ;
51717 int ecode5 = 0 ;
51718 int val6 ;
51719 int ecode6 = 0 ;
51720 PyObject * obj0 = 0 ;
51721 PyObject * obj1 = 0 ;
51722 PyObject * obj2 = 0 ;
51723 PyObject * obj3 = 0 ;
51724 PyObject * obj4 = 0 ;
51725 PyObject * obj5 = 0 ;
51726 char * kwnames[] = {
51727 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51728 };
51729
51730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51732 if (!SWIG_IsOK(res1)) {
51733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51734 }
51735 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51736 ecode2 = SWIG_AsVal_int(obj1, &val2);
51737 if (!SWIG_IsOK(ecode2)) {
51738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51739 }
51740 arg2 = static_cast< wxRelationship >(val2);
51741 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51742 if (!SWIG_IsOK(res3)) {
51743 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51744 }
51745 arg3 = reinterpret_cast< wxWindow * >(argp3);
51746 ecode4 = SWIG_AsVal_int(obj3, &val4);
51747 if (!SWIG_IsOK(ecode4)) {
51748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51749 }
51750 arg4 = static_cast< wxEdge >(val4);
51751 if (obj4) {
51752 ecode5 = SWIG_AsVal_int(obj4, &val5);
51753 if (!SWIG_IsOK(ecode5)) {
51754 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51755 }
51756 arg5 = static_cast< int >(val5);
51757 }
51758 if (obj5) {
51759 ecode6 = SWIG_AsVal_int(obj5, &val6);
51760 if (!SWIG_IsOK(ecode6)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51762 }
51763 arg6 = static_cast< int >(val6);
51764 }
51765 {
51766 PyThreadState* __tstate = wxPyBeginAllowThreads();
51767 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51768 wxPyEndAllowThreads(__tstate);
51769 if (PyErr_Occurred()) SWIG_fail;
51770 }
51771 resultobj = SWIG_Py_Void();
51772 return resultobj;
51773 fail:
51774 return NULL;
51775 }
51776
51777
51778 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51779 PyObject *resultobj = 0;
51780 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51781 wxWindow *arg2 = (wxWindow *) 0 ;
51782 int arg3 = (int) 0 ;
51783 void *argp1 = 0 ;
51784 int res1 = 0 ;
51785 void *argp2 = 0 ;
51786 int res2 = 0 ;
51787 int val3 ;
51788 int ecode3 = 0 ;
51789 PyObject * obj0 = 0 ;
51790 PyObject * obj1 = 0 ;
51791 PyObject * obj2 = 0 ;
51792 char * kwnames[] = {
51793 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51794 };
51795
51796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51798 if (!SWIG_IsOK(res1)) {
51799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51800 }
51801 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51802 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51803 if (!SWIG_IsOK(res2)) {
51804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51805 }
51806 arg2 = reinterpret_cast< wxWindow * >(argp2);
51807 if (obj2) {
51808 ecode3 = SWIG_AsVal_int(obj2, &val3);
51809 if (!SWIG_IsOK(ecode3)) {
51810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51811 }
51812 arg3 = static_cast< int >(val3);
51813 }
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 (arg1)->LeftOf(arg2,arg3);
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_Py_Void();
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51828 PyObject *resultobj = 0;
51829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51830 wxWindow *arg2 = (wxWindow *) 0 ;
51831 int arg3 = (int) 0 ;
51832 void *argp1 = 0 ;
51833 int res1 = 0 ;
51834 void *argp2 = 0 ;
51835 int res2 = 0 ;
51836 int val3 ;
51837 int ecode3 = 0 ;
51838 PyObject * obj0 = 0 ;
51839 PyObject * obj1 = 0 ;
51840 PyObject * obj2 = 0 ;
51841 char * kwnames[] = {
51842 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51843 };
51844
51845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51847 if (!SWIG_IsOK(res1)) {
51848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51849 }
51850 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51851 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51852 if (!SWIG_IsOK(res2)) {
51853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51854 }
51855 arg2 = reinterpret_cast< wxWindow * >(argp2);
51856 if (obj2) {
51857 ecode3 = SWIG_AsVal_int(obj2, &val3);
51858 if (!SWIG_IsOK(ecode3)) {
51859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51860 }
51861 arg3 = static_cast< int >(val3);
51862 }
51863 {
51864 PyThreadState* __tstate = wxPyBeginAllowThreads();
51865 (arg1)->RightOf(arg2,arg3);
51866 wxPyEndAllowThreads(__tstate);
51867 if (PyErr_Occurred()) SWIG_fail;
51868 }
51869 resultobj = SWIG_Py_Void();
51870 return resultobj;
51871 fail:
51872 return NULL;
51873 }
51874
51875
51876 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51877 PyObject *resultobj = 0;
51878 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51879 wxWindow *arg2 = (wxWindow *) 0 ;
51880 int arg3 = (int) 0 ;
51881 void *argp1 = 0 ;
51882 int res1 = 0 ;
51883 void *argp2 = 0 ;
51884 int res2 = 0 ;
51885 int val3 ;
51886 int ecode3 = 0 ;
51887 PyObject * obj0 = 0 ;
51888 PyObject * obj1 = 0 ;
51889 PyObject * obj2 = 0 ;
51890 char * kwnames[] = {
51891 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51892 };
51893
51894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51896 if (!SWIG_IsOK(res1)) {
51897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51898 }
51899 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51901 if (!SWIG_IsOK(res2)) {
51902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51903 }
51904 arg2 = reinterpret_cast< wxWindow * >(argp2);
51905 if (obj2) {
51906 ecode3 = SWIG_AsVal_int(obj2, &val3);
51907 if (!SWIG_IsOK(ecode3)) {
51908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51909 }
51910 arg3 = static_cast< int >(val3);
51911 }
51912 {
51913 PyThreadState* __tstate = wxPyBeginAllowThreads();
51914 (arg1)->Above(arg2,arg3);
51915 wxPyEndAllowThreads(__tstate);
51916 if (PyErr_Occurred()) SWIG_fail;
51917 }
51918 resultobj = SWIG_Py_Void();
51919 return resultobj;
51920 fail:
51921 return NULL;
51922 }
51923
51924
51925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51926 PyObject *resultobj = 0;
51927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51928 wxWindow *arg2 = (wxWindow *) 0 ;
51929 int arg3 = (int) 0 ;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 void *argp2 = 0 ;
51933 int res2 = 0 ;
51934 int val3 ;
51935 int ecode3 = 0 ;
51936 PyObject * obj0 = 0 ;
51937 PyObject * obj1 = 0 ;
51938 PyObject * obj2 = 0 ;
51939 char * kwnames[] = {
51940 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51941 };
51942
51943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51945 if (!SWIG_IsOK(res1)) {
51946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51947 }
51948 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51950 if (!SWIG_IsOK(res2)) {
51951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51952 }
51953 arg2 = reinterpret_cast< wxWindow * >(argp2);
51954 if (obj2) {
51955 ecode3 = SWIG_AsVal_int(obj2, &val3);
51956 if (!SWIG_IsOK(ecode3)) {
51957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51958 }
51959 arg3 = static_cast< int >(val3);
51960 }
51961 {
51962 PyThreadState* __tstate = wxPyBeginAllowThreads();
51963 (arg1)->Below(arg2,arg3);
51964 wxPyEndAllowThreads(__tstate);
51965 if (PyErr_Occurred()) SWIG_fail;
51966 }
51967 resultobj = SWIG_Py_Void();
51968 return resultobj;
51969 fail:
51970 return NULL;
51971 }
51972
51973
51974 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51975 PyObject *resultobj = 0;
51976 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51977 wxWindow *arg2 = (wxWindow *) 0 ;
51978 wxEdge arg3 ;
51979 int arg4 = (int) 0 ;
51980 void *argp1 = 0 ;
51981 int res1 = 0 ;
51982 void *argp2 = 0 ;
51983 int res2 = 0 ;
51984 int val3 ;
51985 int ecode3 = 0 ;
51986 int val4 ;
51987 int ecode4 = 0 ;
51988 PyObject * obj0 = 0 ;
51989 PyObject * obj1 = 0 ;
51990 PyObject * obj2 = 0 ;
51991 PyObject * obj3 = 0 ;
51992 char * kwnames[] = {
51993 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51994 };
51995
51996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51998 if (!SWIG_IsOK(res1)) {
51999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52000 }
52001 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52003 if (!SWIG_IsOK(res2)) {
52004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52005 }
52006 arg2 = reinterpret_cast< wxWindow * >(argp2);
52007 ecode3 = SWIG_AsVal_int(obj2, &val3);
52008 if (!SWIG_IsOK(ecode3)) {
52009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52010 }
52011 arg3 = static_cast< wxEdge >(val3);
52012 if (obj3) {
52013 ecode4 = SWIG_AsVal_int(obj3, &val4);
52014 if (!SWIG_IsOK(ecode4)) {
52015 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52016 }
52017 arg4 = static_cast< int >(val4);
52018 }
52019 {
52020 PyThreadState* __tstate = wxPyBeginAllowThreads();
52021 (arg1)->SameAs(arg2,arg3,arg4);
52022 wxPyEndAllowThreads(__tstate);
52023 if (PyErr_Occurred()) SWIG_fail;
52024 }
52025 resultobj = SWIG_Py_Void();
52026 return resultobj;
52027 fail:
52028 return NULL;
52029 }
52030
52031
52032 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52033 PyObject *resultobj = 0;
52034 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52035 wxWindow *arg2 = (wxWindow *) 0 ;
52036 wxEdge arg3 ;
52037 int arg4 ;
52038 void *argp1 = 0 ;
52039 int res1 = 0 ;
52040 void *argp2 = 0 ;
52041 int res2 = 0 ;
52042 int val3 ;
52043 int ecode3 = 0 ;
52044 int val4 ;
52045 int ecode4 = 0 ;
52046 PyObject * obj0 = 0 ;
52047 PyObject * obj1 = 0 ;
52048 PyObject * obj2 = 0 ;
52049 PyObject * obj3 = 0 ;
52050 char * kwnames[] = {
52051 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52052 };
52053
52054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52056 if (!SWIG_IsOK(res1)) {
52057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52058 }
52059 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52061 if (!SWIG_IsOK(res2)) {
52062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52063 }
52064 arg2 = reinterpret_cast< wxWindow * >(argp2);
52065 ecode3 = SWIG_AsVal_int(obj2, &val3);
52066 if (!SWIG_IsOK(ecode3)) {
52067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52068 }
52069 arg3 = static_cast< wxEdge >(val3);
52070 ecode4 = SWIG_AsVal_int(obj3, &val4);
52071 if (!SWIG_IsOK(ecode4)) {
52072 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52073 }
52074 arg4 = static_cast< int >(val4);
52075 {
52076 PyThreadState* __tstate = wxPyBeginAllowThreads();
52077 (arg1)->PercentOf(arg2,arg3,arg4);
52078 wxPyEndAllowThreads(__tstate);
52079 if (PyErr_Occurred()) SWIG_fail;
52080 }
52081 resultobj = SWIG_Py_Void();
52082 return resultobj;
52083 fail:
52084 return NULL;
52085 }
52086
52087
52088 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52089 PyObject *resultobj = 0;
52090 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52091 int arg2 ;
52092 void *argp1 = 0 ;
52093 int res1 = 0 ;
52094 int val2 ;
52095 int ecode2 = 0 ;
52096 PyObject * obj0 = 0 ;
52097 PyObject * obj1 = 0 ;
52098 char * kwnames[] = {
52099 (char *) "self",(char *) "val", NULL
52100 };
52101
52102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52104 if (!SWIG_IsOK(res1)) {
52105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52106 }
52107 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52108 ecode2 = SWIG_AsVal_int(obj1, &val2);
52109 if (!SWIG_IsOK(ecode2)) {
52110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52111 }
52112 arg2 = static_cast< int >(val2);
52113 {
52114 PyThreadState* __tstate = wxPyBeginAllowThreads();
52115 (arg1)->Absolute(arg2);
52116 wxPyEndAllowThreads(__tstate);
52117 if (PyErr_Occurred()) SWIG_fail;
52118 }
52119 resultobj = SWIG_Py_Void();
52120 return resultobj;
52121 fail:
52122 return NULL;
52123 }
52124
52125
52126 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52127 PyObject *resultobj = 0;
52128 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52129 void *argp1 = 0 ;
52130 int res1 = 0 ;
52131 PyObject *swig_obj[1] ;
52132
52133 if (!args) SWIG_fail;
52134 swig_obj[0] = args;
52135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52136 if (!SWIG_IsOK(res1)) {
52137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52138 }
52139 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52140 {
52141 PyThreadState* __tstate = wxPyBeginAllowThreads();
52142 (arg1)->Unconstrained();
52143 wxPyEndAllowThreads(__tstate);
52144 if (PyErr_Occurred()) SWIG_fail;
52145 }
52146 resultobj = SWIG_Py_Void();
52147 return resultobj;
52148 fail:
52149 return NULL;
52150 }
52151
52152
52153 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52154 PyObject *resultobj = 0;
52155 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52156 void *argp1 = 0 ;
52157 int res1 = 0 ;
52158 PyObject *swig_obj[1] ;
52159
52160 if (!args) SWIG_fail;
52161 swig_obj[0] = args;
52162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52163 if (!SWIG_IsOK(res1)) {
52164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52165 }
52166 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52167 {
52168 PyThreadState* __tstate = wxPyBeginAllowThreads();
52169 (arg1)->AsIs();
52170 wxPyEndAllowThreads(__tstate);
52171 if (PyErr_Occurred()) SWIG_fail;
52172 }
52173 resultobj = SWIG_Py_Void();
52174 return resultobj;
52175 fail:
52176 return NULL;
52177 }
52178
52179
52180 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52181 PyObject *resultobj = 0;
52182 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52183 wxWindow *result = 0 ;
52184 void *argp1 = 0 ;
52185 int res1 = 0 ;
52186 PyObject *swig_obj[1] ;
52187
52188 if (!args) SWIG_fail;
52189 swig_obj[0] = args;
52190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52191 if (!SWIG_IsOK(res1)) {
52192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52193 }
52194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52195 {
52196 PyThreadState* __tstate = wxPyBeginAllowThreads();
52197 result = (wxWindow *)(arg1)->GetOtherWindow();
52198 wxPyEndAllowThreads(__tstate);
52199 if (PyErr_Occurred()) SWIG_fail;
52200 }
52201 {
52202 resultobj = wxPyMake_wxObject(result, 0);
52203 }
52204 return resultobj;
52205 fail:
52206 return NULL;
52207 }
52208
52209
52210 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52211 PyObject *resultobj = 0;
52212 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52213 wxEdge result;
52214 void *argp1 = 0 ;
52215 int res1 = 0 ;
52216 PyObject *swig_obj[1] ;
52217
52218 if (!args) SWIG_fail;
52219 swig_obj[0] = args;
52220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52221 if (!SWIG_IsOK(res1)) {
52222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52223 }
52224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52225 {
52226 PyThreadState* __tstate = wxPyBeginAllowThreads();
52227 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52228 wxPyEndAllowThreads(__tstate);
52229 if (PyErr_Occurred()) SWIG_fail;
52230 }
52231 resultobj = SWIG_From_int(static_cast< int >(result));
52232 return resultobj;
52233 fail:
52234 return NULL;
52235 }
52236
52237
52238 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52239 PyObject *resultobj = 0;
52240 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52241 wxEdge arg2 ;
52242 void *argp1 = 0 ;
52243 int res1 = 0 ;
52244 int val2 ;
52245 int ecode2 = 0 ;
52246 PyObject * obj0 = 0 ;
52247 PyObject * obj1 = 0 ;
52248 char * kwnames[] = {
52249 (char *) "self",(char *) "which", NULL
52250 };
52251
52252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52256 }
52257 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52258 ecode2 = SWIG_AsVal_int(obj1, &val2);
52259 if (!SWIG_IsOK(ecode2)) {
52260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52261 }
52262 arg2 = static_cast< wxEdge >(val2);
52263 {
52264 PyThreadState* __tstate = wxPyBeginAllowThreads();
52265 (arg1)->SetEdge(arg2);
52266 wxPyEndAllowThreads(__tstate);
52267 if (PyErr_Occurred()) SWIG_fail;
52268 }
52269 resultobj = SWIG_Py_Void();
52270 return resultobj;
52271 fail:
52272 return NULL;
52273 }
52274
52275
52276 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52277 PyObject *resultobj = 0;
52278 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52279 int arg2 ;
52280 void *argp1 = 0 ;
52281 int res1 = 0 ;
52282 int val2 ;
52283 int ecode2 = 0 ;
52284 PyObject * obj0 = 0 ;
52285 PyObject * obj1 = 0 ;
52286 char * kwnames[] = {
52287 (char *) "self",(char *) "v", NULL
52288 };
52289
52290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52292 if (!SWIG_IsOK(res1)) {
52293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52294 }
52295 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52296 ecode2 = SWIG_AsVal_int(obj1, &val2);
52297 if (!SWIG_IsOK(ecode2)) {
52298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52299 }
52300 arg2 = static_cast< int >(val2);
52301 {
52302 PyThreadState* __tstate = wxPyBeginAllowThreads();
52303 (arg1)->SetValue(arg2);
52304 wxPyEndAllowThreads(__tstate);
52305 if (PyErr_Occurred()) SWIG_fail;
52306 }
52307 resultobj = SWIG_Py_Void();
52308 return resultobj;
52309 fail:
52310 return NULL;
52311 }
52312
52313
52314 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52315 PyObject *resultobj = 0;
52316 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52317 int result;
52318 void *argp1 = 0 ;
52319 int res1 = 0 ;
52320 PyObject *swig_obj[1] ;
52321
52322 if (!args) SWIG_fail;
52323 swig_obj[0] = args;
52324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52325 if (!SWIG_IsOK(res1)) {
52326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52327 }
52328 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52329 {
52330 PyThreadState* __tstate = wxPyBeginAllowThreads();
52331 result = (int)(arg1)->GetMargin();
52332 wxPyEndAllowThreads(__tstate);
52333 if (PyErr_Occurred()) SWIG_fail;
52334 }
52335 resultobj = SWIG_From_int(static_cast< int >(result));
52336 return resultobj;
52337 fail:
52338 return NULL;
52339 }
52340
52341
52342 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52343 PyObject *resultobj = 0;
52344 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52345 int arg2 ;
52346 void *argp1 = 0 ;
52347 int res1 = 0 ;
52348 int val2 ;
52349 int ecode2 = 0 ;
52350 PyObject * obj0 = 0 ;
52351 PyObject * obj1 = 0 ;
52352 char * kwnames[] = {
52353 (char *) "self",(char *) "m", NULL
52354 };
52355
52356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52358 if (!SWIG_IsOK(res1)) {
52359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52360 }
52361 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52362 ecode2 = SWIG_AsVal_int(obj1, &val2);
52363 if (!SWIG_IsOK(ecode2)) {
52364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52365 }
52366 arg2 = static_cast< int >(val2);
52367 {
52368 PyThreadState* __tstate = wxPyBeginAllowThreads();
52369 (arg1)->SetMargin(arg2);
52370 wxPyEndAllowThreads(__tstate);
52371 if (PyErr_Occurred()) SWIG_fail;
52372 }
52373 resultobj = SWIG_Py_Void();
52374 return resultobj;
52375 fail:
52376 return NULL;
52377 }
52378
52379
52380 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52381 PyObject *resultobj = 0;
52382 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52383 int result;
52384 void *argp1 = 0 ;
52385 int res1 = 0 ;
52386 PyObject *swig_obj[1] ;
52387
52388 if (!args) SWIG_fail;
52389 swig_obj[0] = args;
52390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52391 if (!SWIG_IsOK(res1)) {
52392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52393 }
52394 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52395 {
52396 PyThreadState* __tstate = wxPyBeginAllowThreads();
52397 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52398 wxPyEndAllowThreads(__tstate);
52399 if (PyErr_Occurred()) SWIG_fail;
52400 }
52401 resultobj = SWIG_From_int(static_cast< int >(result));
52402 return resultobj;
52403 fail:
52404 return NULL;
52405 }
52406
52407
52408 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52409 PyObject *resultobj = 0;
52410 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52411 int result;
52412 void *argp1 = 0 ;
52413 int res1 = 0 ;
52414 PyObject *swig_obj[1] ;
52415
52416 if (!args) SWIG_fail;
52417 swig_obj[0] = args;
52418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52419 if (!SWIG_IsOK(res1)) {
52420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52421 }
52422 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52423 {
52424 PyThreadState* __tstate = wxPyBeginAllowThreads();
52425 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52426 wxPyEndAllowThreads(__tstate);
52427 if (PyErr_Occurred()) SWIG_fail;
52428 }
52429 resultobj = SWIG_From_int(static_cast< int >(result));
52430 return resultobj;
52431 fail:
52432 return NULL;
52433 }
52434
52435
52436 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52437 PyObject *resultobj = 0;
52438 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52439 int result;
52440 void *argp1 = 0 ;
52441 int res1 = 0 ;
52442 PyObject *swig_obj[1] ;
52443
52444 if (!args) SWIG_fail;
52445 swig_obj[0] = args;
52446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52447 if (!SWIG_IsOK(res1)) {
52448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52449 }
52450 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52451 {
52452 PyThreadState* __tstate = wxPyBeginAllowThreads();
52453 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52454 wxPyEndAllowThreads(__tstate);
52455 if (PyErr_Occurred()) SWIG_fail;
52456 }
52457 resultobj = SWIG_From_int(static_cast< int >(result));
52458 return resultobj;
52459 fail:
52460 return NULL;
52461 }
52462
52463
52464 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52465 PyObject *resultobj = 0;
52466 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52467 bool result;
52468 void *argp1 = 0 ;
52469 int res1 = 0 ;
52470 PyObject *swig_obj[1] ;
52471
52472 if (!args) SWIG_fail;
52473 swig_obj[0] = args;
52474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52475 if (!SWIG_IsOK(res1)) {
52476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52477 }
52478 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52479 {
52480 PyThreadState* __tstate = wxPyBeginAllowThreads();
52481 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52482 wxPyEndAllowThreads(__tstate);
52483 if (PyErr_Occurred()) SWIG_fail;
52484 }
52485 {
52486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52487 }
52488 return resultobj;
52489 fail:
52490 return NULL;
52491 }
52492
52493
52494 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52495 PyObject *resultobj = 0;
52496 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52497 bool arg2 ;
52498 void *argp1 = 0 ;
52499 int res1 = 0 ;
52500 bool val2 ;
52501 int ecode2 = 0 ;
52502 PyObject * obj0 = 0 ;
52503 PyObject * obj1 = 0 ;
52504 char * kwnames[] = {
52505 (char *) "self",(char *) "d", NULL
52506 };
52507
52508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52510 if (!SWIG_IsOK(res1)) {
52511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52512 }
52513 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52514 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52515 if (!SWIG_IsOK(ecode2)) {
52516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52517 }
52518 arg2 = static_cast< bool >(val2);
52519 {
52520 PyThreadState* __tstate = wxPyBeginAllowThreads();
52521 (arg1)->SetDone(arg2);
52522 wxPyEndAllowThreads(__tstate);
52523 if (PyErr_Occurred()) SWIG_fail;
52524 }
52525 resultobj = SWIG_Py_Void();
52526 return resultobj;
52527 fail:
52528 return NULL;
52529 }
52530
52531
52532 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52533 PyObject *resultobj = 0;
52534 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52535 wxRelationship result;
52536 void *argp1 = 0 ;
52537 int res1 = 0 ;
52538 PyObject *swig_obj[1] ;
52539
52540 if (!args) SWIG_fail;
52541 swig_obj[0] = args;
52542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52543 if (!SWIG_IsOK(res1)) {
52544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52545 }
52546 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52547 {
52548 PyThreadState* __tstate = wxPyBeginAllowThreads();
52549 result = (wxRelationship)(arg1)->GetRelationship();
52550 wxPyEndAllowThreads(__tstate);
52551 if (PyErr_Occurred()) SWIG_fail;
52552 }
52553 resultobj = SWIG_From_int(static_cast< int >(result));
52554 return resultobj;
52555 fail:
52556 return NULL;
52557 }
52558
52559
52560 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52561 PyObject *resultobj = 0;
52562 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52563 wxRelationship arg2 ;
52564 void *argp1 = 0 ;
52565 int res1 = 0 ;
52566 int val2 ;
52567 int ecode2 = 0 ;
52568 PyObject * obj0 = 0 ;
52569 PyObject * obj1 = 0 ;
52570 char * kwnames[] = {
52571 (char *) "self",(char *) "r", NULL
52572 };
52573
52574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52576 if (!SWIG_IsOK(res1)) {
52577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52578 }
52579 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52580 ecode2 = SWIG_AsVal_int(obj1, &val2);
52581 if (!SWIG_IsOK(ecode2)) {
52582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52583 }
52584 arg2 = static_cast< wxRelationship >(val2);
52585 {
52586 PyThreadState* __tstate = wxPyBeginAllowThreads();
52587 (arg1)->SetRelationship(arg2);
52588 wxPyEndAllowThreads(__tstate);
52589 if (PyErr_Occurred()) SWIG_fail;
52590 }
52591 resultobj = SWIG_Py_Void();
52592 return resultobj;
52593 fail:
52594 return NULL;
52595 }
52596
52597
52598 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52599 PyObject *resultobj = 0;
52600 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52601 wxWindow *arg2 = (wxWindow *) 0 ;
52602 bool result;
52603 void *argp1 = 0 ;
52604 int res1 = 0 ;
52605 void *argp2 = 0 ;
52606 int res2 = 0 ;
52607 PyObject * obj0 = 0 ;
52608 PyObject * obj1 = 0 ;
52609 char * kwnames[] = {
52610 (char *) "self",(char *) "otherW", NULL
52611 };
52612
52613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52615 if (!SWIG_IsOK(res1)) {
52616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52617 }
52618 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52620 if (!SWIG_IsOK(res2)) {
52621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52622 }
52623 arg2 = reinterpret_cast< wxWindow * >(argp2);
52624 {
52625 PyThreadState* __tstate = wxPyBeginAllowThreads();
52626 result = (bool)(arg1)->ResetIfWin(arg2);
52627 wxPyEndAllowThreads(__tstate);
52628 if (PyErr_Occurred()) SWIG_fail;
52629 }
52630 {
52631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52632 }
52633 return resultobj;
52634 fail:
52635 return NULL;
52636 }
52637
52638
52639 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52640 PyObject *resultobj = 0;
52641 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52642 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52643 wxWindow *arg3 = (wxWindow *) 0 ;
52644 bool result;
52645 void *argp1 = 0 ;
52646 int res1 = 0 ;
52647 void *argp2 = 0 ;
52648 int res2 = 0 ;
52649 void *argp3 = 0 ;
52650 int res3 = 0 ;
52651 PyObject * obj0 = 0 ;
52652 PyObject * obj1 = 0 ;
52653 PyObject * obj2 = 0 ;
52654 char * kwnames[] = {
52655 (char *) "self",(char *) "constraints",(char *) "win", NULL
52656 };
52657
52658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52660 if (!SWIG_IsOK(res1)) {
52661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52662 }
52663 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52664 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52665 if (!SWIG_IsOK(res2)) {
52666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52667 }
52668 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52669 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52670 if (!SWIG_IsOK(res3)) {
52671 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52672 }
52673 arg3 = reinterpret_cast< wxWindow * >(argp3);
52674 {
52675 PyThreadState* __tstate = wxPyBeginAllowThreads();
52676 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52677 wxPyEndAllowThreads(__tstate);
52678 if (PyErr_Occurred()) SWIG_fail;
52679 }
52680 {
52681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52682 }
52683 return resultobj;
52684 fail:
52685 return NULL;
52686 }
52687
52688
52689 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52690 PyObject *resultobj = 0;
52691 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52692 wxEdge arg2 ;
52693 wxWindow *arg3 = (wxWindow *) 0 ;
52694 wxWindow *arg4 = (wxWindow *) 0 ;
52695 int result;
52696 void *argp1 = 0 ;
52697 int res1 = 0 ;
52698 int val2 ;
52699 int ecode2 = 0 ;
52700 void *argp3 = 0 ;
52701 int res3 = 0 ;
52702 void *argp4 = 0 ;
52703 int res4 = 0 ;
52704 PyObject * obj0 = 0 ;
52705 PyObject * obj1 = 0 ;
52706 PyObject * obj2 = 0 ;
52707 PyObject * obj3 = 0 ;
52708 char * kwnames[] = {
52709 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52710 };
52711
52712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52714 if (!SWIG_IsOK(res1)) {
52715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52716 }
52717 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52718 ecode2 = SWIG_AsVal_int(obj1, &val2);
52719 if (!SWIG_IsOK(ecode2)) {
52720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52721 }
52722 arg2 = static_cast< wxEdge >(val2);
52723 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52724 if (!SWIG_IsOK(res3)) {
52725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52726 }
52727 arg3 = reinterpret_cast< wxWindow * >(argp3);
52728 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52729 if (!SWIG_IsOK(res4)) {
52730 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52731 }
52732 arg4 = reinterpret_cast< wxWindow * >(argp4);
52733 {
52734 PyThreadState* __tstate = wxPyBeginAllowThreads();
52735 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52736 wxPyEndAllowThreads(__tstate);
52737 if (PyErr_Occurred()) SWIG_fail;
52738 }
52739 resultobj = SWIG_From_int(static_cast< int >(result));
52740 return resultobj;
52741 fail:
52742 return NULL;
52743 }
52744
52745
52746 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52747 PyObject *obj;
52748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52749 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52750 return SWIG_Py_Void();
52751 }
52752
52753 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52754 PyObject *resultobj = 0;
52755 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52756 wxIndividualLayoutConstraint *result = 0 ;
52757 void *argp1 = 0 ;
52758 int res1 = 0 ;
52759 PyObject *swig_obj[1] ;
52760
52761 if (!args) SWIG_fail;
52762 swig_obj[0] = args;
52763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52764 if (!SWIG_IsOK(res1)) {
52765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52766 }
52767 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52768 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52770 return resultobj;
52771 fail:
52772 return NULL;
52773 }
52774
52775
52776 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52777 PyObject *resultobj = 0;
52778 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52779 wxIndividualLayoutConstraint *result = 0 ;
52780 void *argp1 = 0 ;
52781 int res1 = 0 ;
52782 PyObject *swig_obj[1] ;
52783
52784 if (!args) SWIG_fail;
52785 swig_obj[0] = args;
52786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52787 if (!SWIG_IsOK(res1)) {
52788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52789 }
52790 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52791 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52793 return resultobj;
52794 fail:
52795 return NULL;
52796 }
52797
52798
52799 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52800 PyObject *resultobj = 0;
52801 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52802 wxIndividualLayoutConstraint *result = 0 ;
52803 void *argp1 = 0 ;
52804 int res1 = 0 ;
52805 PyObject *swig_obj[1] ;
52806
52807 if (!args) SWIG_fail;
52808 swig_obj[0] = args;
52809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52810 if (!SWIG_IsOK(res1)) {
52811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52812 }
52813 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52814 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52816 return resultobj;
52817 fail:
52818 return NULL;
52819 }
52820
52821
52822 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52823 PyObject *resultobj = 0;
52824 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52825 wxIndividualLayoutConstraint *result = 0 ;
52826 void *argp1 = 0 ;
52827 int res1 = 0 ;
52828 PyObject *swig_obj[1] ;
52829
52830 if (!args) SWIG_fail;
52831 swig_obj[0] = args;
52832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52833 if (!SWIG_IsOK(res1)) {
52834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52835 }
52836 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52837 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52839 return resultobj;
52840 fail:
52841 return NULL;
52842 }
52843
52844
52845 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52846 PyObject *resultobj = 0;
52847 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52848 wxIndividualLayoutConstraint *result = 0 ;
52849 void *argp1 = 0 ;
52850 int res1 = 0 ;
52851 PyObject *swig_obj[1] ;
52852
52853 if (!args) SWIG_fail;
52854 swig_obj[0] = args;
52855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52856 if (!SWIG_IsOK(res1)) {
52857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52858 }
52859 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52860 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52862 return resultobj;
52863 fail:
52864 return NULL;
52865 }
52866
52867
52868 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52869 PyObject *resultobj = 0;
52870 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52871 wxIndividualLayoutConstraint *result = 0 ;
52872 void *argp1 = 0 ;
52873 int res1 = 0 ;
52874 PyObject *swig_obj[1] ;
52875
52876 if (!args) SWIG_fail;
52877 swig_obj[0] = args;
52878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52879 if (!SWIG_IsOK(res1)) {
52880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52881 }
52882 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52883 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52885 return resultobj;
52886 fail:
52887 return NULL;
52888 }
52889
52890
52891 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52892 PyObject *resultobj = 0;
52893 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52894 wxIndividualLayoutConstraint *result = 0 ;
52895 void *argp1 = 0 ;
52896 int res1 = 0 ;
52897 PyObject *swig_obj[1] ;
52898
52899 if (!args) SWIG_fail;
52900 swig_obj[0] = args;
52901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52902 if (!SWIG_IsOK(res1)) {
52903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52904 }
52905 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52906 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52908 return resultobj;
52909 fail:
52910 return NULL;
52911 }
52912
52913
52914 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52915 PyObject *resultobj = 0;
52916 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52917 wxIndividualLayoutConstraint *result = 0 ;
52918 void *argp1 = 0 ;
52919 int res1 = 0 ;
52920 PyObject *swig_obj[1] ;
52921
52922 if (!args) SWIG_fail;
52923 swig_obj[0] = args;
52924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52925 if (!SWIG_IsOK(res1)) {
52926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52927 }
52928 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52929 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52931 return resultobj;
52932 fail:
52933 return NULL;
52934 }
52935
52936
52937 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52938 PyObject *resultobj = 0;
52939 wxLayoutConstraints *result = 0 ;
52940
52941 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52942 {
52943 PyThreadState* __tstate = wxPyBeginAllowThreads();
52944 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52945 wxPyEndAllowThreads(__tstate);
52946 if (PyErr_Occurred()) SWIG_fail;
52947 }
52948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52949 return resultobj;
52950 fail:
52951 return NULL;
52952 }
52953
52954
52955 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52956 PyObject *resultobj = 0;
52957 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52958 void *argp1 = 0 ;
52959 int res1 = 0 ;
52960 PyObject *swig_obj[1] ;
52961
52962 if (!args) SWIG_fail;
52963 swig_obj[0] = args;
52964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52965 if (!SWIG_IsOK(res1)) {
52966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52967 }
52968 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52969 {
52970 PyThreadState* __tstate = wxPyBeginAllowThreads();
52971 delete arg1;
52972
52973 wxPyEndAllowThreads(__tstate);
52974 if (PyErr_Occurred()) SWIG_fail;
52975 }
52976 resultobj = SWIG_Py_Void();
52977 return resultobj;
52978 fail:
52979 return NULL;
52980 }
52981
52982
52983 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52984 PyObject *resultobj = 0;
52985 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52986 wxWindow *arg2 = (wxWindow *) 0 ;
52987 int *arg3 = (int *) 0 ;
52988 bool result;
52989 void *argp1 = 0 ;
52990 int res1 = 0 ;
52991 void *argp2 = 0 ;
52992 int res2 = 0 ;
52993 int temp3 ;
52994 int res3 = SWIG_TMPOBJ ;
52995 PyObject * obj0 = 0 ;
52996 PyObject * obj1 = 0 ;
52997 char * kwnames[] = {
52998 (char *) "self",(char *) "win", NULL
52999 };
53000
53001 arg3 = &temp3;
53002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53004 if (!SWIG_IsOK(res1)) {
53005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53006 }
53007 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53009 if (!SWIG_IsOK(res2)) {
53010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53011 }
53012 arg2 = reinterpret_cast< wxWindow * >(argp2);
53013 {
53014 PyThreadState* __tstate = wxPyBeginAllowThreads();
53015 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53016 wxPyEndAllowThreads(__tstate);
53017 if (PyErr_Occurred()) SWIG_fail;
53018 }
53019 {
53020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53021 }
53022 if (SWIG_IsTmpObj(res3)) {
53023 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53024 } else {
53025 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53026 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53027 }
53028 return resultobj;
53029 fail:
53030 return NULL;
53031 }
53032
53033
53034 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53035 PyObject *resultobj = 0;
53036 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53037 bool result;
53038 void *argp1 = 0 ;
53039 int res1 = 0 ;
53040 PyObject *swig_obj[1] ;
53041
53042 if (!args) SWIG_fail;
53043 swig_obj[0] = args;
53044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53045 if (!SWIG_IsOK(res1)) {
53046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53047 }
53048 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53049 {
53050 PyThreadState* __tstate = wxPyBeginAllowThreads();
53051 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53052 wxPyEndAllowThreads(__tstate);
53053 if (PyErr_Occurred()) SWIG_fail;
53054 }
53055 {
53056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53057 }
53058 return resultobj;
53059 fail:
53060 return NULL;
53061 }
53062
53063
53064 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53065 PyObject *obj;
53066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53067 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53068 return SWIG_Py_Void();
53069 }
53070
53071 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53072 return SWIG_Python_InitShadowInstance(args);
53073 }
53074
53075 static PyMethodDef SwigMethods[] = {
53076 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53077 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53078 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53079 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53080 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53081 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53082 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53083 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53084 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53086 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53097 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53098 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53099 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53101 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53102 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53103 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53104 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53105 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53106 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53107 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53109 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53115 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53116 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53117 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53118 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53119 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53120 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53121 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53123 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53131 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53132 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53133 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53138 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53139 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53141 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53143 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53145 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53147 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53149 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53151 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53152 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53154 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53156 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53157 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53158 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53159 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53179 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53180 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53181 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53182 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53183 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53184 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53185 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53186 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53188 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53189 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53190 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53195 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53196 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53197 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53198 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53205 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53212 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53213 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53214 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53215 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53217 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53218 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53219 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53221 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53222 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53223 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53224 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53229 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53230 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53231 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53232 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53233 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53234 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53237 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53238 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53239 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53241 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53242 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53244 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53245 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53246 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53247 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53248 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53249 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53250 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53251 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53252 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53253 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53254 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53259 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53265 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53266 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53267 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53268 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53270 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53273 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53275 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53278 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53279 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53280 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53283 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53284 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53285 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53289 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53290 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53291 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53295 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53300 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53301 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53302 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53303 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53304 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53305 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53306 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53313 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53314 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53316 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53318 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53324 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53325 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53327 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53328 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53329 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53330 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53331 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53332 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53333 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53334 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53336 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53337 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53338 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53339 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53340 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53341 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53342 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53343 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53345 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53354 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53366 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53367 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53382 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53383 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53384 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53385 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53388 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53390 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53392 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53394 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53396 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53399 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53400 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53401 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53402 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53404 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53421 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53422 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53428 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53429 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53431 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53432 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53434 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53435 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53436 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53437 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53438 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53439 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53440 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53441 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53442 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53443 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53444 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53445 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53446 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53447 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53448 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53449 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53450 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53451 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53452 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53453 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53454 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53455 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53456 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53457 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53458 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53459 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53460 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53461 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53462 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53463 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53465 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53466 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53467 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53468 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53471 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53475 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53479 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53480 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53481 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53482 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53484 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53485 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53487 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53489 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53491 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53493 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53494 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53495 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53497 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53498 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53500 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53501 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53502 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53504 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53505 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53506 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53508 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53510 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53511 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53512 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53514 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53516 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53517 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53519 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53520 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53521 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53523 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53524 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53525 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53526 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53527 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53529 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53530 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53533 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53534 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53536 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53537 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53540 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53541 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53543 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53549 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53550 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53551 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53552 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53553 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53554 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53555 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53556 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53557 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53558 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53559 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53560 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53561 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53562 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53563 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53564 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53565 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53566 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53567 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53568 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53569 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53570 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53571 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53572 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53574 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53575 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53576 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53577 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53578 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53579 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53580 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53581 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53582 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53583 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53584 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53585 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53586 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53587 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53588 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53589 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53590 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53591 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53592 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53593 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53594 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53595 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53596 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53597 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53598 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53599 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53600 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53601 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53602 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53603 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53604 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53605 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53607 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53608 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53610 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53611 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53612 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53613 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53615 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53616 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53617 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53618 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53619 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53620 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53621 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53622 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53623 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53625 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53626 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53627 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53628 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53629 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53630 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53631 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53632 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53633 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53634 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53635 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53636 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53637 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53638 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53639 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53640 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53641 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53642 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53643 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53644 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53645 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53646 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53647 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53648 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53649 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53650 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53651 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53652 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53654 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53655 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53658 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53659 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53660 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53661 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53662 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53663 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53665 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53666 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53669 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53670 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53672 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53673 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53675 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53676 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53678 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53679 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53680 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53682 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53684 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53685 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53687 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53688 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53689 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53691 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53692 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53693 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53695 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53696 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53698 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53699 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53700 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53701 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53702 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53705 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53707 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53709 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53710 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53711 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53714 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53715 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53716 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53718 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53719 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53720 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53722 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53723 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53724 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53725 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53726 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53727 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53729 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53730 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53731 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53732 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53733 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53734 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53735 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53736 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53742 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53744 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53746 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53747 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53748 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53749 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53750 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53751 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53753 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53754 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53755 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53757 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53758 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53759 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53760 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53761 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53764 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53765 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53766 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53769 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53770 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53771 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53772 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53773 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53775 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53777 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53780 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53782 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53783 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53785 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53786 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53787 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53789 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53790 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53791 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53793 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53795 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53796 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53797 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53799 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53801 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53803 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53804 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53806 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53807 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53809 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53811 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53812 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53813 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53815 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53817 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53818 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53819 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53821 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53823 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53824 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53825 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53826 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53828 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53830 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53832 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53834 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53835 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53837 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53838 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53839 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53840 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53841 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53842 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53843 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53844 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53846 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53848 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53850 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53852 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53854 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53856 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53857 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53858 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53859 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53860 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53861 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53867 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53868 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53869 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53870 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53871 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53872 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53873 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53874 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53876 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53878 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53879 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53881 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53882 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53883 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53884 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53886 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53887 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53888 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53889 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53891 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53892 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53894 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53895 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53896 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53898 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53900 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53901 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53902 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53903 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53906 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53907 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53908 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53909 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53911 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53912 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53913 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53914 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53915 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53916 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53917 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53918 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53919 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53920 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53922 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53925 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53926 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53927 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53929 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53931 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53933 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53935 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53936 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53946 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53947 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53951 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53952 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53953 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53954 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53955 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53956 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53957 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53958 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53959 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53960 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53961 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53962 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53963 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53964 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53965 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53967 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53968 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53971 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53972 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53977 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53978 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53981 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53982 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53983 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53984 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53987 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53988 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53989 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53991 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53993 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53994 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53995 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53997 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53999 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54001 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54004 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54005 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54006 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54007 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54008 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54009 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54013 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54014 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54015 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54016 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54023 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54029 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54030 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54031 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54032 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54033 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54035 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54045 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54046 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54047 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54048 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54051 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54052 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54053 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54054 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54056 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54057 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54061 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54067 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54068 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54069 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54070 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54072 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54073 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54075 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54078 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54080 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54081 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54082 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54091 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54095 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54096 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54098 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54109 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54110 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54111 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54112 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54116 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54119 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54121 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54124 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54126 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54127 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54130 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54132 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54133 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54134 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54135 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54137 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54138 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54143 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54144 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54145 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54147 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54148 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54149 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54151 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54153 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54154 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54155 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54157 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54158 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54161 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54169 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54176 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54184 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54187 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54188 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54201 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54203 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54205 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54206 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54208 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54210 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54211 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54213 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54214 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54215 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54219 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54238 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54239 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54241 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54242 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54244 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54245 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54246 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54248 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54249 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54252 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54253 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54255 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54256 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54258 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54261 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54262 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54264 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54266 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54268 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54269 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54271 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54272 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54275 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54277 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54279 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54281 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54284 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54286 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54287 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54288 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54290 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54291 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54292 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54294 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54296 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54297 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54299 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54301 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54302 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54306 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54310 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54311 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54313 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54317 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54319 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54321 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54322 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54323 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54324 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54328 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54329 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54330 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54331 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54333 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54334 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54339 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54340 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54341 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54342 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54343 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54345 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54347 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54349 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54350 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54352 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54354 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54357 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54358 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54359 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54361 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54362 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54363 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54377 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54378 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54379 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54380 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54381 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54382 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54388 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54389 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54393 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54394 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54396 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54397 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54399 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54401 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54402 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54404 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54405 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54406 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54412 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54413 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54414 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54415 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54416 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54417 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54424 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54426 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54427 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54428 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54429 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54430 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54431 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54433 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54437 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54438 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54439 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54440 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54441 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54442 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54443 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54445 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54446 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54447 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54453 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54454 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54455 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54457 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54458 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54459 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54465 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54466 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54467 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54468 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54469 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54473 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54474 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54479 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54480 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54482 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54483 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54488 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54490 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54491 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54492 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54493 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54494 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54499 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54500 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54509 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54510 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54511 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54512 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54515 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54517 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54518 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54519 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54520 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54522 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54527 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54528 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54529 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54530 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54531 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54532 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54533 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54534 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54535 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54536 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54537 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54539 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54540 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54541 { NULL, NULL, 0, NULL }
54542 };
54543
54544
54545 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54546
54547 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54548 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54549 }
54550 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54551 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54552 }
54553 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54554 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54555 }
54556 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54557 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54558 }
54559 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54560 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54561 }
54562 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54563 return (void *)((wxSizer *) ((wxGridSizer *) x));
54564 }
54565 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54566 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54567 }
54568 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54569 return (void *)((wxSizer *) ((wxPySizer *) x));
54570 }
54571 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54572 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54573 }
54574 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54575 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54576 }
54577 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54578 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54579 }
54580 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54581 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54582 }
54583 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54584 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54585 }
54586 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54587 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54588 }
54589 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54590 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54591 }
54592 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54593 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54594 }
54595 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54596 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54597 }
54598 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54599 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54600 }
54601 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54602 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54603 }
54604 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54605 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54606 }
54607 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54608 return (void *)((wxEvent *) ((wxPyEvent *) x));
54609 }
54610 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54611 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54612 }
54613 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54614 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54615 }
54616 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54617 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54618 }
54619 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54620 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54621 }
54622 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54623 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54624 }
54625 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54626 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54627 }
54628 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54629 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54630 }
54631 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54632 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54633 }
54634 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54635 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54636 }
54637 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54638 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54639 }
54640 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54641 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54642 }
54643 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54644 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54645 }
54646 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54647 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54648 }
54649 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54650 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54651 }
54652 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54653 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54654 }
54655 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54656 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54657 }
54658 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54659 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54660 }
54661 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54662 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54663 }
54664 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54665 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54666 }
54667 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54668 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54669 }
54670 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54671 return (void *)((wxEvent *) ((wxShowEvent *) x));
54672 }
54673 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54674 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54675 }
54676 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54677 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54678 }
54679 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54680 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54681 }
54682 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54683 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54684 }
54685 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54686 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54687 }
54688 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54689 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54690 }
54691 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54692 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54693 }
54694 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54695 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54696 }
54697 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54698 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54699 }
54700 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54701 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54702 }
54703 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54704 return (void *)((wxControl *) ((wxControlWithItems *) x));
54705 }
54706 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54707 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54708 }
54709 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54710 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54711 }
54712 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54713 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54714 }
54715 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54716 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54717 }
54718 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54719 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54720 }
54721 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54722 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54723 }
54724 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54725 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54726 }
54727 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54728 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54729 }
54730 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54731 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54732 }
54733 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54734 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54735 }
54736 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54737 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54738 }
54739 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54740 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54741 }
54742 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54743 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54744 }
54745 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54746 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54747 }
54748 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54749 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54750 }
54751 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54752 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54753 }
54754 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54755 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54756 }
54757 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54758 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54759 }
54760 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54761 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54762 }
54763 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54764 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54765 }
54766 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54767 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54768 }
54769 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54770 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54771 }
54772 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54773 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54774 }
54775 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54776 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54777 }
54778 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54779 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54780 }
54781 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54782 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54783 }
54784 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54785 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54786 }
54787 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54788 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54789 }
54790 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54791 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54792 }
54793 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54794 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54795 }
54796 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54797 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54798 }
54799 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54800 return (void *)((wxObject *) ((wxSizerItem *) x));
54801 }
54802 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54803 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54804 }
54805 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54806 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54807 }
54808 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54809 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54810 }
54811 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54812 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54813 }
54814 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54815 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54816 }
54817 static void *_p_wxSizerTo_p_wxObject(void *x) {
54818 return (void *)((wxObject *) ((wxSizer *) x));
54819 }
54820 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54821 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54822 }
54823 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54824 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54825 }
54826 static void *_p_wxEventTo_p_wxObject(void *x) {
54827 return (void *)((wxObject *) ((wxEvent *) x));
54828 }
54829 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54830 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54831 }
54832 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54833 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54834 }
54835 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54836 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54837 }
54838 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54839 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54840 }
54841 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54842 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54843 }
54844 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54845 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54846 }
54847 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54848 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54849 }
54850 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54851 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54852 }
54853 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54854 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54855 }
54856 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54857 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54858 }
54859 static void *_p_wxControlTo_p_wxObject(void *x) {
54860 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54861 }
54862 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54863 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54864 }
54865 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54866 return (void *)((wxObject *) ((wxFSFile *) x));
54867 }
54868 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54869 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54870 }
54871 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54872 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54873 }
54874 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54875 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54876 }
54877 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54878 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54879 }
54880 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54881 return (void *)((wxObject *) ((wxMenuItem *) x));
54882 }
54883 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54884 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54885 }
54886 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54887 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54888 }
54889 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54890 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54891 }
54892 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54893 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54894 }
54895 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54896 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54897 }
54898 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54899 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54900 }
54901 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54902 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54903 }
54904 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54905 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54906 }
54907 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54908 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54909 }
54910 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54911 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54912 }
54913 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54914 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54915 }
54916 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54917 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54918 }
54919 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54920 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54921 }
54922 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54923 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54924 }
54925 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54926 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54927 }
54928 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54929 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54930 }
54931 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54932 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54933 }
54934 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54935 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54936 }
54937 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54938 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54939 }
54940 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54941 return (void *)((wxObject *) ((wxImageHandler *) x));
54942 }
54943 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54944 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54945 }
54946 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54947 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54948 }
54949 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54950 return (void *)((wxObject *) ((wxEvtHandler *) x));
54951 }
54952 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54953 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54954 }
54955 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54956 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54957 }
54958 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54959 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54960 }
54961 static void *_p_wxImageTo_p_wxObject(void *x) {
54962 return (void *)((wxObject *) ((wxImage *) x));
54963 }
54964 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54965 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54966 }
54967 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54968 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54969 }
54970 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54971 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54972 }
54973 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54974 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54975 }
54976 static void *_p_wxWindowTo_p_wxObject(void *x) {
54977 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54978 }
54979 static void *_p_wxMenuTo_p_wxObject(void *x) {
54980 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54981 }
54982 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54983 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54984 }
54985 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54986 return (void *)((wxObject *) ((wxFileSystem *) x));
54987 }
54988 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54989 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54990 }
54991 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54992 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54993 }
54994 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54995 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54996 }
54997 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54998 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54999 }
55000 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55001 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55002 }
55003 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55004 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55005 }
55006 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55007 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55008 }
55009 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55010 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55011 }
55012 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55013 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55014 }
55015 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55016 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55017 }
55018 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55019 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55020 }
55021 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55022 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55023 }
55024 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55025 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55026 }
55027 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55028 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55029 }
55030 static void *_p_wxControlTo_p_wxWindow(void *x) {
55031 return (void *)((wxWindow *) ((wxControl *) x));
55032 }
55033 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55034 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55035 }
55036 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55037 return (void *)((wxWindow *) ((wxMenuBar *) x));
55038 }
55039 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55040 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55041 }
55042 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55043 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55044 }
55045 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55046 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55047 }
55048 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55049 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55050 }
55051 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55052 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55053 }
55054 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55055 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55056 }
55057 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55058 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55059 }
55060 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55061 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55062 }
55063 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55064 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55065 }
55066 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55067 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55068 }
55069 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55070 return (void *)((wxValidator *) ((wxPyValidator *) x));
55071 }
55072 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55074 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};
55075 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55177 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55178 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55179 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55180 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55181 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55182 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55183 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55184 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55185 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55186 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55187 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55188 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55189 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55190 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55191 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55192 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55193 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55194 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55195 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55196 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55197 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55198 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55199 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55200 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55201 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55202 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55203 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55204
55205 static swig_type_info *swig_type_initial[] = {
55206 &_swigt__p_buffer,
55207 &_swigt__p_char,
55208 &_swigt__p_form_ops_t,
55209 &_swigt__p_int,
55210 &_swigt__p_long,
55211 &_swigt__p_unsigned_char,
55212 &_swigt__p_unsigned_int,
55213 &_swigt__p_unsigned_long,
55214 &_swigt__p_wxANIHandler,
55215 &_swigt__p_wxAcceleratorEntry,
55216 &_swigt__p_wxAcceleratorTable,
55217 &_swigt__p_wxActivateEvent,
55218 &_swigt__p_wxAppTraits,
55219 &_swigt__p_wxArrayString,
55220 &_swigt__p_wxBMPHandler,
55221 &_swigt__p_wxBitmap,
55222 &_swigt__p_wxBoxSizer,
55223 &_swigt__p_wxButton,
55224 &_swigt__p_wxCURHandler,
55225 &_swigt__p_wxCaret,
55226 &_swigt__p_wxChildFocusEvent,
55227 &_swigt__p_wxClipboardTextEvent,
55228 &_swigt__p_wxCloseEvent,
55229 &_swigt__p_wxColour,
55230 &_swigt__p_wxCommandEvent,
55231 &_swigt__p_wxContextMenuEvent,
55232 &_swigt__p_wxControl,
55233 &_swigt__p_wxControlWithItems,
55234 &_swigt__p_wxCursor,
55235 &_swigt__p_wxDC,
55236 &_swigt__p_wxDateEvent,
55237 &_swigt__p_wxDateTime,
55238 &_swigt__p_wxDisplayChangedEvent,
55239 &_swigt__p_wxDropFilesEvent,
55240 &_swigt__p_wxDuplexMode,
55241 &_swigt__p_wxEraseEvent,
55242 &_swigt__p_wxEvent,
55243 &_swigt__p_wxEventLoop,
55244 &_swigt__p_wxEventLoopActivator,
55245 &_swigt__p_wxEvtHandler,
55246 &_swigt__p_wxFSFile,
55247 &_swigt__p_wxFileSystem,
55248 &_swigt__p_wxFileSystemHandler,
55249 &_swigt__p_wxFlexGridSizer,
55250 &_swigt__p_wxFocusEvent,
55251 &_swigt__p_wxFont,
55252 &_swigt__p_wxFrame,
55253 &_swigt__p_wxGBPosition,
55254 &_swigt__p_wxGBSizerItem,
55255 &_swigt__p_wxGBSpan,
55256 &_swigt__p_wxGIFHandler,
55257 &_swigt__p_wxGridBagSizer,
55258 &_swigt__p_wxGridSizer,
55259 &_swigt__p_wxHelpEvent__Origin,
55260 &_swigt__p_wxICOHandler,
55261 &_swigt__p_wxIconizeEvent,
55262 &_swigt__p_wxIdleEvent,
55263 &_swigt__p_wxImage,
55264 &_swigt__p_wxImageHandler,
55265 &_swigt__p_wxImageHistogram,
55266 &_swigt__p_wxImage_HSVValue,
55267 &_swigt__p_wxImage_RGBValue,
55268 &_swigt__p_wxIndividualLayoutConstraint,
55269 &_swigt__p_wxInitDialogEvent,
55270 &_swigt__p_wxInputStream,
55271 &_swigt__p_wxInternetFSHandler,
55272 &_swigt__p_wxItemContainer,
55273 &_swigt__p_wxJPEGHandler,
55274 &_swigt__p_wxKeyEvent,
55275 &_swigt__p_wxLayoutConstraints,
55276 &_swigt__p_wxMaximizeEvent,
55277 &_swigt__p_wxMemoryFSHandler,
55278 &_swigt__p_wxMenu,
55279 &_swigt__p_wxMenuBar,
55280 &_swigt__p_wxMenuBarBase,
55281 &_swigt__p_wxMenuEvent,
55282 &_swigt__p_wxMenuItem,
55283 &_swigt__p_wxMouseCaptureChangedEvent,
55284 &_swigt__p_wxMouseCaptureLostEvent,
55285 &_swigt__p_wxMouseEvent,
55286 &_swigt__p_wxMoveEvent,
55287 &_swigt__p_wxNavigationKeyEvent,
55288 &_swigt__p_wxNcPaintEvent,
55289 &_swigt__p_wxNotifyEvent,
55290 &_swigt__p_wxObject,
55291 &_swigt__p_wxOutputStream,
55292 &_swigt__p_wxPCXHandler,
55293 &_swigt__p_wxPNGHandler,
55294 &_swigt__p_wxPNMHandler,
55295 &_swigt__p_wxPaintEvent,
55296 &_swigt__p_wxPaletteChangedEvent,
55297 &_swigt__p_wxPaperSize,
55298 &_swigt__p_wxPoint,
55299 &_swigt__p_wxPoint2D,
55300 &_swigt__p_wxPropagateOnce,
55301 &_swigt__p_wxPropagationDisabler,
55302 &_swigt__p_wxPyApp,
55303 &_swigt__p_wxPyCommandEvent,
55304 &_swigt__p_wxPyDropTarget,
55305 &_swigt__p_wxPyEvent,
55306 &_swigt__p_wxPyFileSystemHandler,
55307 &_swigt__p_wxPyImageHandler,
55308 &_swigt__p_wxPyInputStream,
55309 &_swigt__p_wxPySizer,
55310 &_swigt__p_wxPyValidator,
55311 &_swigt__p_wxQuantize,
55312 &_swigt__p_wxQueryNewPaletteEvent,
55313 &_swigt__p_wxRealPoint,
55314 &_swigt__p_wxRect,
55315 &_swigt__p_wxRegion,
55316 &_swigt__p_wxScrollEvent,
55317 &_swigt__p_wxScrollWinEvent,
55318 &_swigt__p_wxSetCursorEvent,
55319 &_swigt__p_wxShowEvent,
55320 &_swigt__p_wxSize,
55321 &_swigt__p_wxSizeEvent,
55322 &_swigt__p_wxSizer,
55323 &_swigt__p_wxSizerItem,
55324 &_swigt__p_wxStaticBox,
55325 &_swigt__p_wxStaticBoxSizer,
55326 &_swigt__p_wxStdDialogButtonSizer,
55327 &_swigt__p_wxSysColourChangedEvent,
55328 &_swigt__p_wxTIFFHandler,
55329 &_swigt__p_wxToolTip,
55330 &_swigt__p_wxUpdateUIEvent,
55331 &_swigt__p_wxValidator,
55332 &_swigt__p_wxVisualAttributes,
55333 &_swigt__p_wxWindow,
55334 &_swigt__p_wxWindowCreateEvent,
55335 &_swigt__p_wxWindowDestroyEvent,
55336 &_swigt__p_wxXPMHandler,
55337 &_swigt__p_wxZipFSHandler,
55338 };
55339
55340 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55341 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55343 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55344 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55345 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55346 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55347 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55348 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55354 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}};
55355 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55356 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}};
55357 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55358 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}};
55359 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55361 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55362 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55363 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55364 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}};
55365 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55366 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}};
55367 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55369 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55370 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55372 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55373 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55374 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55375 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55376 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}};
55377 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55379 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}};
55380 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55382 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}};
55383 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}};
55384 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55387 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55388 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55392 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}};
55393 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55394 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}};
55395 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55398 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}};
55399 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55406 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}};
55407 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55424 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}};
55425 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55429 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55430 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55431 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55432 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55437 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55438 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55439 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55440 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55441 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55442 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55445 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55446 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55447 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55448 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55449 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55450 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55451 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55452 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55453 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55454 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55455 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55456 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}};
55457 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}};
55458 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55459 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55460 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55461 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55462 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55463 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55464 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55465 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}};
55466 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55467 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}};
55468 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55469 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55470 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55471 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55472
55473 static swig_cast_info *swig_cast_initial[] = {
55474 _swigc__p_buffer,
55475 _swigc__p_char,
55476 _swigc__p_form_ops_t,
55477 _swigc__p_int,
55478 _swigc__p_long,
55479 _swigc__p_unsigned_char,
55480 _swigc__p_unsigned_int,
55481 _swigc__p_unsigned_long,
55482 _swigc__p_wxANIHandler,
55483 _swigc__p_wxAcceleratorEntry,
55484 _swigc__p_wxAcceleratorTable,
55485 _swigc__p_wxActivateEvent,
55486 _swigc__p_wxAppTraits,
55487 _swigc__p_wxArrayString,
55488 _swigc__p_wxBMPHandler,
55489 _swigc__p_wxBitmap,
55490 _swigc__p_wxBoxSizer,
55491 _swigc__p_wxButton,
55492 _swigc__p_wxCURHandler,
55493 _swigc__p_wxCaret,
55494 _swigc__p_wxChildFocusEvent,
55495 _swigc__p_wxClipboardTextEvent,
55496 _swigc__p_wxCloseEvent,
55497 _swigc__p_wxColour,
55498 _swigc__p_wxCommandEvent,
55499 _swigc__p_wxContextMenuEvent,
55500 _swigc__p_wxControl,
55501 _swigc__p_wxControlWithItems,
55502 _swigc__p_wxCursor,
55503 _swigc__p_wxDC,
55504 _swigc__p_wxDateEvent,
55505 _swigc__p_wxDateTime,
55506 _swigc__p_wxDisplayChangedEvent,
55507 _swigc__p_wxDropFilesEvent,
55508 _swigc__p_wxDuplexMode,
55509 _swigc__p_wxEraseEvent,
55510 _swigc__p_wxEvent,
55511 _swigc__p_wxEventLoop,
55512 _swigc__p_wxEventLoopActivator,
55513 _swigc__p_wxEvtHandler,
55514 _swigc__p_wxFSFile,
55515 _swigc__p_wxFileSystem,
55516 _swigc__p_wxFileSystemHandler,
55517 _swigc__p_wxFlexGridSizer,
55518 _swigc__p_wxFocusEvent,
55519 _swigc__p_wxFont,
55520 _swigc__p_wxFrame,
55521 _swigc__p_wxGBPosition,
55522 _swigc__p_wxGBSizerItem,
55523 _swigc__p_wxGBSpan,
55524 _swigc__p_wxGIFHandler,
55525 _swigc__p_wxGridBagSizer,
55526 _swigc__p_wxGridSizer,
55527 _swigc__p_wxHelpEvent__Origin,
55528 _swigc__p_wxICOHandler,
55529 _swigc__p_wxIconizeEvent,
55530 _swigc__p_wxIdleEvent,
55531 _swigc__p_wxImage,
55532 _swigc__p_wxImageHandler,
55533 _swigc__p_wxImageHistogram,
55534 _swigc__p_wxImage_HSVValue,
55535 _swigc__p_wxImage_RGBValue,
55536 _swigc__p_wxIndividualLayoutConstraint,
55537 _swigc__p_wxInitDialogEvent,
55538 _swigc__p_wxInputStream,
55539 _swigc__p_wxInternetFSHandler,
55540 _swigc__p_wxItemContainer,
55541 _swigc__p_wxJPEGHandler,
55542 _swigc__p_wxKeyEvent,
55543 _swigc__p_wxLayoutConstraints,
55544 _swigc__p_wxMaximizeEvent,
55545 _swigc__p_wxMemoryFSHandler,
55546 _swigc__p_wxMenu,
55547 _swigc__p_wxMenuBar,
55548 _swigc__p_wxMenuBarBase,
55549 _swigc__p_wxMenuEvent,
55550 _swigc__p_wxMenuItem,
55551 _swigc__p_wxMouseCaptureChangedEvent,
55552 _swigc__p_wxMouseCaptureLostEvent,
55553 _swigc__p_wxMouseEvent,
55554 _swigc__p_wxMoveEvent,
55555 _swigc__p_wxNavigationKeyEvent,
55556 _swigc__p_wxNcPaintEvent,
55557 _swigc__p_wxNotifyEvent,
55558 _swigc__p_wxObject,
55559 _swigc__p_wxOutputStream,
55560 _swigc__p_wxPCXHandler,
55561 _swigc__p_wxPNGHandler,
55562 _swigc__p_wxPNMHandler,
55563 _swigc__p_wxPaintEvent,
55564 _swigc__p_wxPaletteChangedEvent,
55565 _swigc__p_wxPaperSize,
55566 _swigc__p_wxPoint,
55567 _swigc__p_wxPoint2D,
55568 _swigc__p_wxPropagateOnce,
55569 _swigc__p_wxPropagationDisabler,
55570 _swigc__p_wxPyApp,
55571 _swigc__p_wxPyCommandEvent,
55572 _swigc__p_wxPyDropTarget,
55573 _swigc__p_wxPyEvent,
55574 _swigc__p_wxPyFileSystemHandler,
55575 _swigc__p_wxPyImageHandler,
55576 _swigc__p_wxPyInputStream,
55577 _swigc__p_wxPySizer,
55578 _swigc__p_wxPyValidator,
55579 _swigc__p_wxQuantize,
55580 _swigc__p_wxQueryNewPaletteEvent,
55581 _swigc__p_wxRealPoint,
55582 _swigc__p_wxRect,
55583 _swigc__p_wxRegion,
55584 _swigc__p_wxScrollEvent,
55585 _swigc__p_wxScrollWinEvent,
55586 _swigc__p_wxSetCursorEvent,
55587 _swigc__p_wxShowEvent,
55588 _swigc__p_wxSize,
55589 _swigc__p_wxSizeEvent,
55590 _swigc__p_wxSizer,
55591 _swigc__p_wxSizerItem,
55592 _swigc__p_wxStaticBox,
55593 _swigc__p_wxStaticBoxSizer,
55594 _swigc__p_wxStdDialogButtonSizer,
55595 _swigc__p_wxSysColourChangedEvent,
55596 _swigc__p_wxTIFFHandler,
55597 _swigc__p_wxToolTip,
55598 _swigc__p_wxUpdateUIEvent,
55599 _swigc__p_wxValidator,
55600 _swigc__p_wxVisualAttributes,
55601 _swigc__p_wxWindow,
55602 _swigc__p_wxWindowCreateEvent,
55603 _swigc__p_wxWindowDestroyEvent,
55604 _swigc__p_wxXPMHandler,
55605 _swigc__p_wxZipFSHandler,
55606 };
55607
55608
55609 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55610
55611 static swig_const_info swig_const_table[] = {
55612 {0, 0, 0, 0.0, 0, 0}};
55613
55614 #ifdef __cplusplus
55615 }
55616 #endif
55617 /* -----------------------------------------------------------------------------
55618 * Type initialization:
55619 * This problem is tough by the requirement that no dynamic
55620 * memory is used. Also, since swig_type_info structures store pointers to
55621 * swig_cast_info structures and swig_cast_info structures store pointers back
55622 * to swig_type_info structures, we need some lookup code at initialization.
55623 * The idea is that swig generates all the structures that are needed.
55624 * The runtime then collects these partially filled structures.
55625 * The SWIG_InitializeModule function takes these initial arrays out of
55626 * swig_module, and does all the lookup, filling in the swig_module.types
55627 * array with the correct data and linking the correct swig_cast_info
55628 * structures together.
55629 *
55630 * The generated swig_type_info structures are assigned staticly to an initial
55631 * array. We just loop though that array, and handle each type individually.
55632 * First we lookup if this type has been already loaded, and if so, use the
55633 * loaded structure instead of the generated one. Then we have to fill in the
55634 * cast linked list. The cast data is initially stored in something like a
55635 * two-dimensional array. Each row corresponds to a type (there are the same
55636 * number of rows as there are in the swig_type_initial array). Each entry in
55637 * a column is one of the swig_cast_info structures for that type.
55638 * The cast_initial array is actually an array of arrays, because each row has
55639 * a variable number of columns. So to actually build the cast linked list,
55640 * we find the array of casts associated with the type, and loop through it
55641 * adding the casts to the list. The one last trick we need to do is making
55642 * sure the type pointer in the swig_cast_info struct is correct.
55643 *
55644 * First off, we lookup the cast->type name to see if it is already loaded.
55645 * There are three cases to handle:
55646 * 1) If the cast->type has already been loaded AND the type we are adding
55647 * casting info to has not been loaded (it is in this module), THEN we
55648 * replace the cast->type pointer with the type pointer that has already
55649 * been loaded.
55650 * 2) If BOTH types (the one we are adding casting info to, and the
55651 * cast->type) are loaded, THEN the cast info has already been loaded by
55652 * the previous module so we just ignore it.
55653 * 3) Finally, if cast->type has not already been loaded, then we add that
55654 * swig_cast_info to the linked list (because the cast->type) pointer will
55655 * be correct.
55656 * ----------------------------------------------------------------------------- */
55657
55658 #ifdef __cplusplus
55659 extern "C" {
55660 #if 0
55661 } /* c-mode */
55662 #endif
55663 #endif
55664
55665 #if 0
55666 #define SWIGRUNTIME_DEBUG
55667 #endif
55668
55669 SWIGRUNTIME void
55670 SWIG_InitializeModule(void *clientdata) {
55671 size_t i;
55672 swig_module_info *module_head;
55673 static int init_run = 0;
55674
55675 clientdata = clientdata;
55676
55677 if (init_run) return;
55678 init_run = 1;
55679
55680 /* Initialize the swig_module */
55681 swig_module.type_initial = swig_type_initial;
55682 swig_module.cast_initial = swig_cast_initial;
55683
55684 /* Try and load any already created modules */
55685 module_head = SWIG_GetModule(clientdata);
55686 if (module_head) {
55687 swig_module.next = module_head->next;
55688 module_head->next = &swig_module;
55689 } else {
55690 /* This is the first module loaded */
55691 swig_module.next = &swig_module;
55692 SWIG_SetModule(clientdata, &swig_module);
55693 }
55694
55695 /* Now work on filling in swig_module.types */
55696 #ifdef SWIGRUNTIME_DEBUG
55697 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55698 #endif
55699 for (i = 0; i < swig_module.size; ++i) {
55700 swig_type_info *type = 0;
55701 swig_type_info *ret;
55702 swig_cast_info *cast;
55703
55704 #ifdef SWIGRUNTIME_DEBUG
55705 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55706 #endif
55707
55708 /* if there is another module already loaded */
55709 if (swig_module.next != &swig_module) {
55710 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55711 }
55712 if (type) {
55713 /* Overwrite clientdata field */
55714 #ifdef SWIGRUNTIME_DEBUG
55715 printf("SWIG_InitializeModule: found type %s\n", type->name);
55716 #endif
55717 if (swig_module.type_initial[i]->clientdata) {
55718 type->clientdata = swig_module.type_initial[i]->clientdata;
55719 #ifdef SWIGRUNTIME_DEBUG
55720 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55721 #endif
55722 }
55723 } else {
55724 type = swig_module.type_initial[i];
55725 }
55726
55727 /* Insert casting types */
55728 cast = swig_module.cast_initial[i];
55729 while (cast->type) {
55730 /* Don't need to add information already in the list */
55731 ret = 0;
55732 #ifdef SWIGRUNTIME_DEBUG
55733 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55734 #endif
55735 if (swig_module.next != &swig_module) {
55736 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55737 #ifdef SWIGRUNTIME_DEBUG
55738 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55739 #endif
55740 }
55741 if (ret) {
55742 if (type == swig_module.type_initial[i]) {
55743 #ifdef SWIGRUNTIME_DEBUG
55744 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55745 #endif
55746 cast->type = ret;
55747 ret = 0;
55748 } else {
55749 /* Check for casting already in the list */
55750 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55751 #ifdef SWIGRUNTIME_DEBUG
55752 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55753 #endif
55754 if (!ocast) ret = 0;
55755 }
55756 }
55757
55758 if (!ret) {
55759 #ifdef SWIGRUNTIME_DEBUG
55760 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55761 #endif
55762 if (type->cast) {
55763 type->cast->prev = cast;
55764 cast->next = type->cast;
55765 }
55766 type->cast = cast;
55767 }
55768 cast++;
55769 }
55770 /* Set entry in modules->types array equal to the type */
55771 swig_module.types[i] = type;
55772 }
55773 swig_module.types[i] = 0;
55774
55775 #ifdef SWIGRUNTIME_DEBUG
55776 printf("**** SWIG_InitializeModule: Cast List ******\n");
55777 for (i = 0; i < swig_module.size; ++i) {
55778 int j = 0;
55779 swig_cast_info *cast = swig_module.cast_initial[i];
55780 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55781 while (cast->type) {
55782 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55783 cast++;
55784 ++j;
55785 }
55786 printf("---- Total casts: %d\n",j);
55787 }
55788 printf("**** SWIG_InitializeModule: Cast List ******\n");
55789 #endif
55790 }
55791
55792 /* This function will propagate the clientdata field of type to
55793 * any new swig_type_info structures that have been added into the list
55794 * of equivalent types. It is like calling
55795 * SWIG_TypeClientData(type, clientdata) a second time.
55796 */
55797 SWIGRUNTIME void
55798 SWIG_PropagateClientData(void) {
55799 size_t i;
55800 swig_cast_info *equiv;
55801 static int init_run = 0;
55802
55803 if (init_run) return;
55804 init_run = 1;
55805
55806 for (i = 0; i < swig_module.size; i++) {
55807 if (swig_module.types[i]->clientdata) {
55808 equiv = swig_module.types[i]->cast;
55809 while (equiv) {
55810 if (!equiv->converter) {
55811 if (equiv->type && !equiv->type->clientdata)
55812 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55813 }
55814 equiv = equiv->next;
55815 }
55816 }
55817 }
55818 }
55819
55820 #ifdef __cplusplus
55821 #if 0
55822 {
55823 /* c-mode */
55824 #endif
55825 }
55826 #endif
55827
55828
55829
55830 #ifdef __cplusplus
55831 extern "C" {
55832 #endif
55833
55834 /* Python-specific SWIG API */
55835 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55836 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55837 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55838
55839 /* -----------------------------------------------------------------------------
55840 * global variable support code.
55841 * ----------------------------------------------------------------------------- */
55842
55843 typedef struct swig_globalvar {
55844 char *name; /* Name of global variable */
55845 PyObject *(*get_attr)(void); /* Return the current value */
55846 int (*set_attr)(PyObject *); /* Set the value */
55847 struct swig_globalvar *next;
55848 } swig_globalvar;
55849
55850 typedef struct swig_varlinkobject {
55851 PyObject_HEAD
55852 swig_globalvar *vars;
55853 } swig_varlinkobject;
55854
55855 SWIGINTERN PyObject *
55856 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55857 return PyString_FromString("<Swig global variables>");
55858 }
55859
55860 SWIGINTERN PyObject *
55861 swig_varlink_str(swig_varlinkobject *v) {
55862 PyObject *str = PyString_FromString("(");
55863 swig_globalvar *var;
55864 for (var = v->vars; var; var=var->next) {
55865 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55866 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55867 }
55868 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55869 return str;
55870 }
55871
55872 SWIGINTERN int
55873 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55874 PyObject *str = swig_varlink_str(v);
55875 fprintf(fp,"Swig global variables ");
55876 fprintf(fp,"%s\n", PyString_AsString(str));
55877 Py_DECREF(str);
55878 return 0;
55879 }
55880
55881 SWIGINTERN void
55882 swig_varlink_dealloc(swig_varlinkobject *v) {
55883 swig_globalvar *var = v->vars;
55884 while (var) {
55885 swig_globalvar *n = var->next;
55886 free(var->name);
55887 free(var);
55888 var = n;
55889 }
55890 }
55891
55892 SWIGINTERN PyObject *
55893 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55894 PyObject *res = NULL;
55895 swig_globalvar *var = v->vars;
55896 while (var) {
55897 if (strcmp(var->name,n) == 0) {
55898 res = (*var->get_attr)();
55899 break;
55900 }
55901 var = var->next;
55902 }
55903 if (res == NULL && !PyErr_Occurred()) {
55904 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55905 }
55906 return res;
55907 }
55908
55909 SWIGINTERN int
55910 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55911 int res = 1;
55912 swig_globalvar *var = v->vars;
55913 while (var) {
55914 if (strcmp(var->name,n) == 0) {
55915 res = (*var->set_attr)(p);
55916 break;
55917 }
55918 var = var->next;
55919 }
55920 if (res == 1 && !PyErr_Occurred()) {
55921 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55922 }
55923 return res;
55924 }
55925
55926 SWIGINTERN PyTypeObject*
55927 swig_varlink_type(void) {
55928 static char varlink__doc__[] = "Swig var link object";
55929 static PyTypeObject varlink_type;
55930 static int type_init = 0;
55931 if (!type_init) {
55932 const PyTypeObject tmp
55933 = {
55934 PyObject_HEAD_INIT(NULL)
55935 0, /* Number of items in variable part (ob_size) */
55936 (char *)"swigvarlink", /* Type name (tp_name) */
55937 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55938 0, /* Itemsize (tp_itemsize) */
55939 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55940 (printfunc) swig_varlink_print, /* Print (tp_print) */
55941 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55942 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55943 0, /* tp_compare */
55944 (reprfunc) swig_varlink_repr, /* tp_repr */
55945 0, /* tp_as_number */
55946 0, /* tp_as_sequence */
55947 0, /* tp_as_mapping */
55948 0, /* tp_hash */
55949 0, /* tp_call */
55950 (reprfunc)swig_varlink_str, /* tp_str */
55951 0, /* tp_getattro */
55952 0, /* tp_setattro */
55953 0, /* tp_as_buffer */
55954 0, /* tp_flags */
55955 varlink__doc__, /* tp_doc */
55956 0, /* tp_traverse */
55957 0, /* tp_clear */
55958 0, /* tp_richcompare */
55959 0, /* tp_weaklistoffset */
55960 #if PY_VERSION_HEX >= 0x02020000
55961 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55962 #endif
55963 #if PY_VERSION_HEX >= 0x02030000
55964 0, /* tp_del */
55965 #endif
55966 #ifdef COUNT_ALLOCS
55967 0,0,0,0 /* tp_alloc -> tp_next */
55968 #endif
55969 };
55970 varlink_type = tmp;
55971 varlink_type.ob_type = &PyType_Type;
55972 type_init = 1;
55973 }
55974 return &varlink_type;
55975 }
55976
55977 /* Create a variable linking object for use later */
55978 SWIGINTERN PyObject *
55979 SWIG_Python_newvarlink(void) {
55980 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55981 if (result) {
55982 result->vars = 0;
55983 }
55984 return ((PyObject*) result);
55985 }
55986
55987 SWIGINTERN void
55988 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55989 swig_varlinkobject *v = (swig_varlinkobject *) p;
55990 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55991 if (gv) {
55992 size_t size = strlen(name)+1;
55993 gv->name = (char *)malloc(size);
55994 if (gv->name) {
55995 strncpy(gv->name,name,size);
55996 gv->get_attr = get_attr;
55997 gv->set_attr = set_attr;
55998 gv->next = v->vars;
55999 }
56000 }
56001 v->vars = gv;
56002 }
56003
56004 SWIGINTERN PyObject *
56005 SWIG_globals() {
56006 static PyObject *_SWIG_globals = 0;
56007 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56008 return _SWIG_globals;
56009 }
56010
56011 /* -----------------------------------------------------------------------------
56012 * constants/methods manipulation
56013 * ----------------------------------------------------------------------------- */
56014
56015 /* Install Constants */
56016 SWIGINTERN void
56017 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56018 PyObject *obj = 0;
56019 size_t i;
56020 for (i = 0; constants[i].type; ++i) {
56021 switch(constants[i].type) {
56022 case SWIG_PY_POINTER:
56023 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56024 break;
56025 case SWIG_PY_BINARY:
56026 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56027 break;
56028 default:
56029 obj = 0;
56030 break;
56031 }
56032 if (obj) {
56033 PyDict_SetItemString(d, constants[i].name, obj);
56034 Py_DECREF(obj);
56035 }
56036 }
56037 }
56038
56039 /* -----------------------------------------------------------------------------*/
56040 /* Fix SwigMethods to carry the callback ptrs when needed */
56041 /* -----------------------------------------------------------------------------*/
56042
56043 SWIGINTERN void
56044 SWIG_Python_FixMethods(PyMethodDef *methods,
56045 swig_const_info *const_table,
56046 swig_type_info **types,
56047 swig_type_info **types_initial) {
56048 size_t i;
56049 for (i = 0; methods[i].ml_name; ++i) {
56050 const char *c = methods[i].ml_doc;
56051 if (c && (c = strstr(c, "swig_ptr: "))) {
56052 int j;
56053 swig_const_info *ci = 0;
56054 const char *name = c + 10;
56055 for (j = 0; const_table[j].type; ++j) {
56056 if (strncmp(const_table[j].name, name,
56057 strlen(const_table[j].name)) == 0) {
56058 ci = &(const_table[j]);
56059 break;
56060 }
56061 }
56062 if (ci) {
56063 size_t shift = (ci->ptype) - types;
56064 swig_type_info *ty = types_initial[shift];
56065 size_t ldoc = (c - methods[i].ml_doc);
56066 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56067 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56068 if (ndoc) {
56069 char *buff = ndoc;
56070 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56071 if (ptr) {
56072 strncpy(buff, methods[i].ml_doc, ldoc);
56073 buff += ldoc;
56074 strncpy(buff, "swig_ptr: ", 10);
56075 buff += 10;
56076 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56077 methods[i].ml_doc = ndoc;
56078 }
56079 }
56080 }
56081 }
56082 }
56083 }
56084
56085 #ifdef __cplusplus
56086 }
56087 #endif
56088
56089 /* -----------------------------------------------------------------------------*
56090 * Partial Init method
56091 * -----------------------------------------------------------------------------*/
56092
56093 #ifdef __cplusplus
56094 extern "C"
56095 #endif
56096 SWIGEXPORT void SWIG_init(void) {
56097 PyObject *m, *d;
56098
56099 /* Fix SwigMethods to carry the callback ptrs when needed */
56100 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56101
56102 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56103 d = PyModule_GetDict(m);
56104
56105 SWIG_InitializeModule(0);
56106 SWIG_InstallConstants(d,swig_const_table);
56107
56108
56109
56110 #ifndef wxPyUSE_EXPORT
56111 // Make our API structure a CObject so other modules can import it
56112 // from this module.
56113 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56114 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56115 Py_XDECREF(cobj);
56116 #endif
56117
56118 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56119 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56120 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56121 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56122 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56123 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56124 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56125 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56126 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56127 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56128 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56129 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56130 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56131 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56132 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56133 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56134 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56135 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56136 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56137 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56138 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56139 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56140 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56141 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56142 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56143 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56144 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56145 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56146 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56147 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56148 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56149 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56150 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56151 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56152 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56153 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56154 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56155 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56156 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56157 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56158 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56159 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56160 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56161 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56162 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56163 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56164 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56165 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56166 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56167 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56168 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56169 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56170 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56171 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56172 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56173 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56174 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56175 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56176 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56177 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56178 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56179 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56180 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56181 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56182 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56183 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56184 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56185 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56186 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56187 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56188 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56189 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56190 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56191 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56192 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56193 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56194 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56195 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56196 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56197 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56198 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56199 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56200 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56201 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56202 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56203 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56204 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56205 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56206 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56207 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56208 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56209 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56210 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56211 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56212 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56213 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56214 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56215 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56216 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56217 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56218 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56219 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56220 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56221 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56222 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56223 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56224 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56225 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56226 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56227 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56228 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56229 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56230 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56231 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56232 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56233 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56234 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56235 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56236 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56237 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56238 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56239 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56240 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56241 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56242 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56243 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56244 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56245 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56246 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56247 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56248 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56249 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56250 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56251 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56252 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56253 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56254 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56255 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56256 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56257 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56258 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56259 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56260 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56261 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56262 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56263 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56264 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56265 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56266 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56267 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56268 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56269 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56270 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56271 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56272 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56273 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56274 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56275 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56276 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56277 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56278 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56279 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56280 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56281 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56282 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56283 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56284 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56285 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56286 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56287 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56288 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56289 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56290 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56291 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56292 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56293 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56294 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56295 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56296 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56297 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56298 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56299 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56300 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56301 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56302 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56303 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56304 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56305 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56306 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56307 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56308 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56309 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56310 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56311 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56312 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56313 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56314 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56315 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56316 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56317 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56318 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56319 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56320 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56321 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56322 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56323 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56324 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56325 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56326 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56327 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56328 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56329 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56330 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56331 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56332 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56333 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56334 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56335 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56336 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56337 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56338 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56339 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56340 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56341 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56342 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56343 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56344 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56345 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56346 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56347 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56348 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56349 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56350 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56351 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56352 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56353 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56354 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56355 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56356 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56357 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56358 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56359 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56360 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56361 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56362 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56363 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56364 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56365 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56366 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56367 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56368 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56369 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56370 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56371 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56372 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56373 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56374 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56375 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56376 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56377 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56378 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56379 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56380 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56381 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56382 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56383 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56384 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56385 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56386 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56387 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56388 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56389 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56390 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56391 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56392 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56393 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56394 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56395 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56396 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56397 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56398 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56399 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56400 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56401 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56402 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56403 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56404 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56405 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56406 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56407 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56408 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56409 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56410 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56411 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56412 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56413 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56414 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56415 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56416 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56417 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56418 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56419 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56420 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56421 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56422 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56423 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56424 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56425 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56426 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56427 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56428 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56429 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56430 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56431 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56432 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56433 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56434 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56435 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56436 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56437 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56438 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56439 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56440 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56441 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56442 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56443 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56444 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56445 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56446 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56447 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56448 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56449 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56450 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56451 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56452 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56453 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56454 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56455 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56456 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56457 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56458 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56459 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56460 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56461 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56462 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56463 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56464 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56465 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56466 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56467 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56468 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56469 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56470 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56471 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56472 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56473 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56474 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56475 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56476 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56477 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56478 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56479 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56480 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56481 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56482 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56483 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56484 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56485 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56486 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56487 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56488 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56489 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56490 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56491 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56492 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56493 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56494 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56495 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56496 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56497 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56498 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56499 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56500 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56501 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56502 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56503 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56504 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56505 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56506 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56507 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56508 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56509 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56510 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56511 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56512 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56513 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56514 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56515 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56516 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56517 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56518 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56519 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56520 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56521 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56522 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56523 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56524 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56525 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56526 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56527 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56528 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56529 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56530 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56531 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56532 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56533 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56534 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56535 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56536 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56537 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56538 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56539 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56540 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56541 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56542 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56543 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56544 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56545 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56546 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56547 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56548 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56549 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56550 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56551 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56552 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56553 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56554 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56555 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56556 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56557 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56558 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56559 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56560 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56561 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56562 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56563 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56564 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56565 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56566 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56567 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56568 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56569 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56570 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56571 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56572 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56573 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56574 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56575 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56576 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56577 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56578 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56579 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56580 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56581 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56582 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56583 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56584 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56585 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56586 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56587 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56588 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56589 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56590 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56591 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56592 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56593 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56594 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56595 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56596 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56597 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56598 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56599 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56600 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56601 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56602 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56603 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56604 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56605 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56606 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56607 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56608 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56609 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56610 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56611 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56612 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56613 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56614 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56615 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56616 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56617 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56618 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56619 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56620 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56621 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56622 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56623 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56624 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56625 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56626 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56627 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56628 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56629 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56630 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56631 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56632 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56633 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56634 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56635 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56636 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56637 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56638 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56639 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56640 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56641 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56642 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56643 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56644 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56645 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56646 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56647 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56648 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56649 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56650 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56651 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56652 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56653 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56654 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56655 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56656 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56657 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56658 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56659 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56660 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56661 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56662 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56663 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56664 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56665 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56666 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56667 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56668 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56669 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56670 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56671 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56672 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56673 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56674 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56675 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56676 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56677 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56678 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56679 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56680 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56681 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56682 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56683 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56684 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56685 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56686 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56687 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56688 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56689 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56690 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56691 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56692 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56693 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56694 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56695 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56696 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56697 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56698 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56699 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56700 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56701 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56702 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56703 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56704 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56705 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56706 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56707 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56708 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56709 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56710 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56711 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56712 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56713 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56714 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56715 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56716 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56717 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56718 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56719 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56720 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56721 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56722 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56723 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56724 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56725 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56726 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56727 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56728 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56729 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56730 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56731 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56732 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56733 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56734 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56735 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56736 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56737 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56738 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56739 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56740 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56741 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56742 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56743 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56744 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56745 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56746 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56747 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56748 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56749 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56750 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56751 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56752 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56753 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56754 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56755 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56756 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56757 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56758 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56759 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56760 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56761 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56762 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56763 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56764 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56765 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56766 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56767 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56768 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56769 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56770 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56771 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56772 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56773 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56774 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56775 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56776 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56777 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56778 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56779 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56780 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56781 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56782 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56783 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56784
56785 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56786
56787
56788 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56789
56790 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56791 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56792 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56793 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56794 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56795 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56796 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56797 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56798 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56799 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56800 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56801 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56802 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56803 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56804 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56805 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56806 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56807 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56808 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56809 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56810 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56811 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56812 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56813 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56814 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56815 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56816 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56817 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56818 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56819 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56820 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56821 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56822 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56823 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56824 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56825 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56826 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56827 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56828 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56829 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56830 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56831 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56832 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56833 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56834 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56835 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56836 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56837 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56838 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56839 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56840 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56841 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56842 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56843 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56844 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56845 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56846 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56847 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56848 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56849 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56850 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56851 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56852 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56853 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56854 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56855 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56856 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56857 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56858 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56859 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56860 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56861 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56862 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56863 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56864 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56865 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56866 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56867 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56868 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56869 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56870 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56871 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56872 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56873 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56874 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56875 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56876 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56877 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56878 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56879 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56880 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56881 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56882 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56883 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56884 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56885 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56886 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56887 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56888 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56889 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56890 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56891 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56892 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56893 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56894 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56895 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56896 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56897 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56898 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56899 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56900 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56901 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56902 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56903 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56904 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56905 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56906 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56907 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56908 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56909 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56910 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56911 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56912 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56913 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56914 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56915 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56916 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56917 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56918 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56919 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56920 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56921 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56922 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56923 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56924 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56925 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56926 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56927 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56928 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56929 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56930 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56931 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56932 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56933 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56934 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56935 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56936 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56937 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56938 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56939 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56940 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56941 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56942 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56943 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56944 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56945 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56946 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56947 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56948 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56949 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56950 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56951 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56952 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56953 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56954 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56955 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56956 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56957 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56958 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56959 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56960 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56961 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56962 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56963 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56964 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56965 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56966 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56967 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56968 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56969 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56970 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56971 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56972 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56973 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56974 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56975 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56976 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56977 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56978 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56979 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56980 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56981 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56982 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56983 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56984 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56985 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56986 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56987 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56988 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56989 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56990 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56991 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56992 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56993 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56994 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56995 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56996 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56997
56998 // Initialize threading, some globals and such
56999 __wxPyPreStart(d);
57000
57001
57002 // Although these are defined in __version__ they need to be here too so
57003 // that an assert can be done to ensure that the wxPython and the wxWindows
57004 // versions match.
57005 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57006 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57007 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57008
57009 }
57010
wxWidgets (Impactor)